G__IO.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:30:12 2011

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

#define R__DICTIONARY_FILENAME iodIiodIsrcdIG__IO
#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__IO.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 TVirtualArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TVirtualArray_Dictionary();
   static void delete_TVirtualArray(void *p);
   static void deleteArray_TVirtualArray(void *p);
   static void destruct_TVirtualArray(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualArray*)
   {
      ::TVirtualArray *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TVirtualArray),0);
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualArray", 0, "include/TVirtualArray.h", 27,
                  typeid(::TVirtualArray), DefineBehavior(ptr, ptr),
                  0, &TVirtualArray_Dictionary, isa_proxy, 9,
                  sizeof(::TVirtualArray) );
      instance.SetDelete(&delete_TVirtualArray);
      instance.SetDeleteArray(&deleteArray_TVirtualArray);
      instance.SetDestructor(&destruct_TVirtualArray);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualArray*)
   {
      return GenerateInitInstanceLocal((::TVirtualArray*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualArray*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace TStreamerInfoActions {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void TStreamerInfoActions_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("TStreamerInfoActions", 0 /*version*/, "include/TStreamerInfoActions.h", 19,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &TStreamerInfoActions_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void TStreamerInfoActions_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOT {
   void TStreamerInfoActionscLcLTActionSequence_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStreamerInfoActionscLcLTActionSequence(void *p);
   static void deleteArray_TStreamerInfoActionscLcLTActionSequence(void *p);
   static void destruct_TStreamerInfoActionscLcLTActionSequence(void *p);

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

namespace ROOT {
   void TFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFile(void *p = 0);
   static void *newArray_TFile(Long_t size, void *p);
   static void delete_TFile(void *p);
   static void deleteArray_TFile(void *p);
   static void destruct_TFile(void *p);
   static void streamer_TFile(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFile*)
   {
      ::TFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFile", ::TFile::Class_Version(), "include/TFile.h", 41,
                  typeid(::TFile), DefineBehavior(ptr, ptr),
                  &::TFile::Dictionary, isa_proxy, 1,
                  sizeof(::TFile) );
      instance.SetNew(&new_TFile);
      instance.SetNewArray(&newArray_TFile);
      instance.SetDelete(&delete_TFile);
      instance.SetDeleteArray(&deleteArray_TFile);
      instance.SetDestructor(&destruct_TFile);
      instance.SetStreamerFunc(&streamer_TFile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFile*)
   {
      return GenerateInitInstanceLocal((::TFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArchiveMember_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArchiveMember(void *p = 0);
   static void *newArray_TArchiveMember(Long_t size, void *p);
   static void delete_TArchiveMember(void *p);
   static void deleteArray_TArchiveMember(void *p);
   static void destruct_TArchiveMember(void *p);

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

namespace ROOT {
   void TArchiveFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TArchiveFile(void *p);
   static void deleteArray_TArchiveFile(void *p);
   static void destruct_TArchiveFile(void *p);

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

namespace ROOT {
   void TStreamerInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerInfo(void *p = 0);
   static void *newArray_TStreamerInfo(Long_t size, void *p);
   static void delete_TStreamerInfo(void *p);
   static void deleteArray_TStreamerInfo(void *p);
   static void destruct_TStreamerInfo(void *p);
   static void streamer_TStreamerInfo(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerInfo*)
   {
      ::TStreamerInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerInfo", ::TStreamerInfo::Class_Version(), "include/TStreamerInfo.h", 49,
                  typeid(::TStreamerInfo), DefineBehavior(ptr, ptr),
                  &::TStreamerInfo::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerInfo) );
      instance.SetNew(&new_TStreamerInfo);
      instance.SetNewArray(&newArray_TStreamerInfo);
      instance.SetDelete(&delete_TStreamerInfo);
      instance.SetDeleteArray(&deleteArray_TStreamerInfo);
      instance.SetDestructor(&destruct_TStreamerInfo);
      instance.SetStreamerFunc(&streamer_TStreamerInfo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerInfo*)
   {
      return GenerateInitInstanceLocal((::TStreamerInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBufferFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TBufferFile(void *p);
   static void deleteArray_TBufferFile(void *p);
   static void destruct_TBufferFile(void *p);
   static void streamer_TBufferFile(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TCollectionProxyFactory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TCollectionProxyFactory_Dictionary();
   static void *new_TCollectionProxyFactory(void *p = 0);
   static void *newArray_TCollectionProxyFactory(Long_t size, void *p);
   static void delete_TCollectionProxyFactory(void *p);
   static void deleteArray_TCollectionProxyFactory(void *p);
   static void destruct_TCollectionProxyFactory(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollectionProxyFactory*)
   {
      ::TCollectionProxyFactory *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TCollectionProxyFactory),0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollectionProxyFactory", "include/TCollectionProxyFactory.h", 78,
                  typeid(::TCollectionProxyFactory), DefineBehavior(ptr, ptr),
                  0, &TCollectionProxyFactory_Dictionary, isa_proxy, 1,
                  sizeof(::TCollectionProxyFactory) );
      instance.SetNew(&new_TCollectionProxyFactory);
      instance.SetNewArray(&newArray_TCollectionProxyFactory);
      instance.SetDelete(&delete_TCollectionProxyFactory);
      instance.SetDeleteArray(&deleteArray_TCollectionProxyFactory);
      instance.SetDestructor(&destruct_TCollectionProxyFactory);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollectionProxyFactory*)
   {
      return GenerateInitInstanceLocal((::TCollectionProxyFactory*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollectionProxyFactory*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGenCollectionProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGenCollectionProxy_Dictionary();
   static void delete_TGenCollectionProxy(void *p);
   static void deleteArray_TGenCollectionProxy(void *p);
   static void destruct_TGenCollectionProxy(void *p);
   static void streamer_TGenCollectionProxy(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGenCollectionProxy*)
   {
      ::TGenCollectionProxy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGenCollectionProxy),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGenCollectionProxy", "include/TGenCollectionProxy.h", 51,
                  typeid(::TGenCollectionProxy), DefineBehavior(ptr, ptr),
                  0, &TGenCollectionProxy_Dictionary, isa_proxy, 1,
                  sizeof(::TGenCollectionProxy) );
      instance.SetDelete(&delete_TGenCollectionProxy);
      instance.SetDeleteArray(&deleteArray_TGenCollectionProxy);
      instance.SetDestructor(&destruct_TGenCollectionProxy);
      instance.SetStreamerFunc(&streamer_TGenCollectionProxy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGenCollectionProxy*)
   {
      return GenerateInitInstanceLocal((::TGenCollectionProxy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGenCollectionProxy*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGenCollectionProxycLcLValue_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGenCollectionProxycLcLValue_Dictionary();
   static void delete_TGenCollectionProxycLcLValue(void *p);
   static void deleteArray_TGenCollectionProxycLcLValue(void *p);
   static void destruct_TGenCollectionProxycLcLValue(void *p);

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

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

} // end of namespace ROOT

namespace ROOT {
   void TGenCollectionProxycLcLMethod_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGenCollectionProxycLcLMethod_Dictionary();
   static void *new_TGenCollectionProxycLcLMethod(void *p = 0);
   static void *newArray_TGenCollectionProxycLcLMethod(Long_t size, void *p);
   static void delete_TGenCollectionProxycLcLMethod(void *p);
   static void deleteArray_TGenCollectionProxycLcLMethod(void *p);
   static void destruct_TGenCollectionProxycLcLMethod(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGenCollectionProxy::Method*)
   {
      ::TGenCollectionProxy::Method *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGenCollectionProxy::Method),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGenCollectionProxy::Method", "include/TGenCollectionProxy.h", 213,
                  typeid(::TGenCollectionProxy::Method), DefineBehavior(ptr, ptr),
                  0, &TGenCollectionProxycLcLMethod_Dictionary, isa_proxy, 1,
                  sizeof(::TGenCollectionProxy::Method) );
      instance.SetNew(&new_TGenCollectionProxycLcLMethod);
      instance.SetNewArray(&newArray_TGenCollectionProxycLcLMethod);
      instance.SetDelete(&delete_TGenCollectionProxycLcLMethod);
      instance.SetDeleteArray(&deleteArray_TGenCollectionProxycLcLMethod);
      instance.SetDestructor(&destruct_TGenCollectionProxycLcLMethod);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGenCollectionProxy::Method*)
   {
      return GenerateInitInstanceLocal((::TGenCollectionProxy::Method*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGenCollectionProxy::Method*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEmulatedCollectionProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEmulatedCollectionProxy_Dictionary();
   static void delete_TEmulatedCollectionProxy(void *p);
   static void deleteArray_TEmulatedCollectionProxy(void *p);
   static void destruct_TEmulatedCollectionProxy(void *p);
   static void streamer_TEmulatedCollectionProxy(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmulatedCollectionProxy*)
   {
      ::TEmulatedCollectionProxy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TEmulatedCollectionProxy),0);
      static ::ROOT::TGenericClassInfo 
         instance("TEmulatedCollectionProxy", "include/TEmulatedCollectionProxy.h", 31,
                  typeid(::TEmulatedCollectionProxy), DefineBehavior(ptr, ptr),
                  0, &TEmulatedCollectionProxy_Dictionary, isa_proxy, 1,
                  sizeof(::TEmulatedCollectionProxy) );
      instance.SetDelete(&delete_TEmulatedCollectionProxy);
      instance.SetDeleteArray(&deleteArray_TEmulatedCollectionProxy);
      instance.SetDestructor(&destruct_TEmulatedCollectionProxy);
      instance.SetStreamerFunc(&streamer_TEmulatedCollectionProxy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEmulatedCollectionProxy*)
   {
      return GenerateInitInstanceLocal((::TEmulatedCollectionProxy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmulatedCollectionProxy*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TCollectionStreamer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TCollectionStreamer_Dictionary();
   static void *new_TCollectionStreamer(void *p = 0);
   static void *newArray_TCollectionStreamer(Long_t size, void *p);
   static void delete_TCollectionStreamer(void *p);
   static void deleteArray_TCollectionStreamer(void *p);
   static void destruct_TCollectionStreamer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollectionStreamer*)
   {
      ::TCollectionStreamer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TCollectionStreamer),0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollectionStreamer", "include/TCollectionProxyFactory.h", 142,
                  typeid(::TCollectionStreamer), DefineBehavior(ptr, ptr),
                  0, &TCollectionStreamer_Dictionary, isa_proxy, 1,
                  sizeof(::TCollectionStreamer) );
      instance.SetNew(&new_TCollectionStreamer);
      instance.SetNewArray(&newArray_TCollectionStreamer);
      instance.SetDelete(&delete_TCollectionStreamer);
      instance.SetDeleteArray(&deleteArray_TCollectionStreamer);
      instance.SetDestructor(&destruct_TCollectionStreamer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollectionStreamer*)
   {
      return GenerateInitInstanceLocal((::TCollectionStreamer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollectionStreamer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TCollectionClassStreamer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TCollectionClassStreamer_Dictionary();
   static void *new_TCollectionClassStreamer(void *p = 0);
   static void *newArray_TCollectionClassStreamer(Long_t size, void *p);
   static void delete_TCollectionClassStreamer(void *p);
   static void deleteArray_TCollectionClassStreamer(void *p);
   static void destruct_TCollectionClassStreamer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollectionClassStreamer*)
   {
      ::TCollectionClassStreamer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TCollectionClassStreamer),0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollectionClassStreamer", "include/TCollectionProxyFactory.h", 175,
                  typeid(::TCollectionClassStreamer), DefineBehavior(ptr, ptr),
                  0, &TCollectionClassStreamer_Dictionary, isa_proxy, 1,
                  sizeof(::TCollectionClassStreamer) );
      instance.SetNew(&new_TCollectionClassStreamer);
      instance.SetNewArray(&newArray_TCollectionClassStreamer);
      instance.SetDelete(&delete_TCollectionClassStreamer);
      instance.SetDeleteArray(&deleteArray_TCollectionClassStreamer);
      instance.SetDestructor(&destruct_TCollectionClassStreamer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollectionClassStreamer*)
   {
      return GenerateInitInstanceLocal((::TCollectionClassStreamer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollectionClassStreamer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TCollectionMemberStreamer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TCollectionMemberStreamer_Dictionary();
   static void *new_TCollectionMemberStreamer(void *p = 0);
   static void *newArray_TCollectionMemberStreamer(Long_t size, void *p);
   static void delete_TCollectionMemberStreamer(void *p);
   static void deleteArray_TCollectionMemberStreamer(void *p);
   static void destruct_TCollectionMemberStreamer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollectionMemberStreamer*)
   {
      ::TCollectionMemberStreamer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TCollectionMemberStreamer),0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollectionMemberStreamer", "include/TCollectionProxyFactory.h", 221,
                  typeid(::TCollectionMemberStreamer), DefineBehavior(ptr, ptr),
                  0, &TCollectionMemberStreamer_Dictionary, isa_proxy, 1,
                  sizeof(::TCollectionMemberStreamer) );
      instance.SetNew(&new_TCollectionMemberStreamer);
      instance.SetNewArray(&newArray_TCollectionMemberStreamer);
      instance.SetDelete(&delete_TCollectionMemberStreamer);
      instance.SetDeleteArray(&deleteArray_TCollectionMemberStreamer);
      instance.SetDestructor(&destruct_TCollectionMemberStreamer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollectionMemberStreamer*)
   {
      return GenerateInitInstanceLocal((::TCollectionMemberStreamer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollectionMemberStreamer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TKey_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TKey(void *p = 0);
   static void *newArray_TKey(Long_t size, void *p);
   static void delete_TKey(void *p);
   static void deleteArray_TKey(void *p);
   static void destruct_TKey(void *p);
   static void streamer_TKey(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDirectoryFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDirectoryFile(void *p = 0);
   static void *newArray_TDirectoryFile(Long_t size, void *p);
   static void delete_TDirectoryFile(void *p);
   static void deleteArray_TDirectoryFile(void *p);
   static void destruct_TDirectoryFile(void *p);
   static void streamer_TDirectoryFile(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDirectoryFile*)
   {
      ::TDirectoryFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDirectoryFile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDirectoryFile", ::TDirectoryFile::Class_Version(), "include/TDirectoryFile.h", 33,
                  typeid(::TDirectoryFile), DefineBehavior(ptr, ptr),
                  &::TDirectoryFile::Dictionary, isa_proxy, 1,
                  sizeof(::TDirectoryFile) );
      instance.SetNew(&new_TDirectoryFile);
      instance.SetNewArray(&newArray_TDirectoryFile);
      instance.SetDelete(&delete_TDirectoryFile);
      instance.SetDeleteArray(&deleteArray_TDirectoryFile);
      instance.SetDestructor(&destruct_TDirectoryFile);
      instance.SetStreamerFunc(&streamer_TDirectoryFile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDirectoryFile*)
   {
      return GenerateInitInstanceLocal((::TDirectoryFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDirectoryFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEmulatedMapProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEmulatedMapProxy_Dictionary();
   static void delete_TEmulatedMapProxy(void *p);
   static void deleteArray_TEmulatedMapProxy(void *p);
   static void destruct_TEmulatedMapProxy(void *p);
   static void streamer_TEmulatedMapProxy(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmulatedMapProxy*)
   {
      ::TEmulatedMapProxy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TEmulatedMapProxy),0);
      static ::ROOT::TGenericClassInfo 
         instance("TEmulatedMapProxy", "include/TEmulatedMapProxy.h", 25,
                  typeid(::TEmulatedMapProxy), DefineBehavior(ptr, ptr),
                  0, &TEmulatedMapProxy_Dictionary, isa_proxy, 1,
                  sizeof(::TEmulatedMapProxy) );
      instance.SetDelete(&delete_TEmulatedMapProxy);
      instance.SetDeleteArray(&deleteArray_TEmulatedMapProxy);
      instance.SetDestructor(&destruct_TEmulatedMapProxy);
      instance.SetStreamerFunc(&streamer_TEmulatedMapProxy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEmulatedMapProxy*)
   {
      return GenerateInitInstanceLocal((::TEmulatedMapProxy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmulatedMapProxy*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TFileCacheRead_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFileCacheRead(void *p = 0);
   static void *newArray_TFileCacheRead(Long_t size, void *p);
   static void delete_TFileCacheRead(void *p);
   static void deleteArray_TFileCacheRead(void *p);
   static void destruct_TFileCacheRead(void *p);

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

namespace ROOT {
   void TFileCacheWrite_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFileCacheWrite(void *p = 0);
   static void *newArray_TFileCacheWrite(Long_t size, void *p);
   static void delete_TFileCacheWrite(void *p);
   static void deleteArray_TFileCacheWrite(void *p);
   static void destruct_TFileCacheWrite(void *p);

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

namespace ROOT {
   void TFree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFree(void *p = 0);
   static void *newArray_TFree(Long_t size, void *p);
   static void delete_TFree(void *p);
   static void deleteArray_TFree(void *p);
   static void destruct_TFree(void *p);
   static void streamer_TFree(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TMapFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMapFile(void *p);
   static void deleteArray_TMapFile(void *p);
   static void destruct_TMapFile(void *p);
   static void streamer_TMapFile(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TKeyMapFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TKeyMapFile(void *p = 0);
   static void *newArray_TKeyMapFile(Long_t size, void *p);
   static void delete_TKeyMapFile(void *p);
   static void deleteArray_TKeyMapFile(void *p);
   static void destruct_TKeyMapFile(void *p);
   static void streamer_TKeyMapFile(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TKeyMapFile*)
   {
      ::TKeyMapFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TKeyMapFile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TKeyMapFile", ::TKeyMapFile::Class_Version(), "include/TKeyMapFile.h", 31,
                  typeid(::TKeyMapFile), DefineBehavior(ptr, ptr),
                  &::TKeyMapFile::Dictionary, isa_proxy, 0,
                  sizeof(::TKeyMapFile) );
      instance.SetNew(&new_TKeyMapFile);
      instance.SetNewArray(&newArray_TKeyMapFile);
      instance.SetDelete(&delete_TKeyMapFile);
      instance.SetDeleteArray(&deleteArray_TKeyMapFile);
      instance.SetDestructor(&destruct_TKeyMapFile);
      instance.SetStreamerFunc(&streamer_TKeyMapFile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TKeyMapFile*)
   {
      return GenerateInitInstanceLocal((::TKeyMapFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TKeyMapFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLockFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TLockFile(void *p);
   static void deleteArray_TLockFile(void *p);
   static void destruct_TLockFile(void *p);
   static void streamer_TLockFile(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TMapRec_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMapRec_Dictionary();
   static void delete_TMapRec(void *p);
   static void deleteArray_TMapRec(void *p);
   static void destruct_TMapRec(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMapRec*)
   {
      ::TMapRec *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMapRec),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMapRec", "include/TMapFile.h", 155,
                  typeid(::TMapRec), DefineBehavior(ptr, ptr),
                  0, &TMapRec_Dictionary, isa_proxy, 0,
                  sizeof(::TMapRec) );
      instance.SetDelete(&delete_TMapRec);
      instance.SetDeleteArray(&deleteArray_TMapRec);
      instance.SetDestructor(&destruct_TMapRec);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMapRec*)
   {
      return GenerateInitInstanceLocal((::TMapRec*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMapRec*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TStreamerInfoActionscLcLTConfiguration_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TStreamerInfoActionscLcLTConfiguration_Dictionary();
   static void delete_TStreamerInfoActionscLcLTConfiguration(void *p);
   static void deleteArray_TStreamerInfoActionscLcLTConfiguration(void *p);
   static void destruct_TStreamerInfoActionscLcLTConfiguration(void *p);

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

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

} // end of namespace ROOT

namespace ROOT {
   void TStreamerInfoActionscLcLTConfiguredAction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerInfoActionscLcLTConfiguredAction(void *p = 0);
   static void *newArray_TStreamerInfoActionscLcLTConfiguredAction(Long_t size, void *p);
   static void delete_TStreamerInfoActionscLcLTConfiguredAction(void *p);
   static void deleteArray_TStreamerInfoActionscLcLTConfiguredAction(void *p);
   static void destruct_TStreamerInfoActionscLcLTConfiguredAction(void *p);

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

namespace ROOT {
   void TVirtualObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TVirtualObject_Dictionary();
   static void delete_TVirtualObject(void *p);
   static void deleteArray_TVirtualObject(void *p);
   static void destruct_TVirtualObject(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualObject*)
   {
      ::TVirtualObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TVirtualObject),0);
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualObject", 0, "include/TVirtualObject.h", 30,
                  typeid(::TVirtualObject), DefineBehavior(ptr, ptr),
                  0, &TVirtualObject_Dictionary, isa_proxy, 9,
                  sizeof(::TVirtualObject) );
      instance.SetDelete(&delete_TVirtualObject);
      instance.SetDeleteArray(&deleteArray_TVirtualObject);
      instance.SetDestructor(&destruct_TVirtualObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualObject*)
   {
      return GenerateInitInstanceLocal((::TVirtualObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TZIPMember_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TZIPMember(void *p = 0);
   static void *newArray_TZIPMember(Long_t size, void *p);
   static void delete_TZIPMember(void *p);
   static void deleteArray_TZIPMember(void *p);
   static void destruct_TZIPMember(void *p);

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

namespace ROOT {
   void TZIPFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TZIPFile(void *p = 0);
   static void *newArray_TZIPFile(Long_t size, void *p);
   static void delete_TZIPFile(void *p);
   static void deleteArray_TZIPFile(void *p);
   static void destruct_TZIPFile(void *p);

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

      namespace TStreamerInfoActions {
//______________________________________________________________________________
TClass *TActionSequence::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace TStreamerInfoActions
//______________________________________________________________________________
TClass *TFile::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      namespace TStreamerInfoActions {
//______________________________________________________________________________
TClass *TConfiguredAction::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace TStreamerInfoActions
//______________________________________________________________________________
TClass *TZIPMember::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

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

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

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

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

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

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

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

   TBuffer::Streamer(R__b);
}

//______________________________________________________________________________
void TBufferFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBufferFile.
      TClass *R__cl = ::TBufferFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMapCount", &fMapCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMapSize", &fMapSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisplacement", &fDisplacement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPidOffset", &fPidOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMap", &fMap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassMap", &fClassMap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoStack", (void*)&fInfoStack);
      R__insp.InspectMember("TBufferFile::InfoList_t", (void*)&fInfoStack, "fInfoStack.", false);
      TBuffer::ShowMembers(R__insp);
}

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

//______________________________________________________________________________
void TDirectoryFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDirectoryFile.
      TClass *R__cl = ::TDirectoryFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModified", &fModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWritable", &fWritable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDatimeC", &fDatimeC);
      R__insp.InspectMember(fDatimeC, "fDatimeC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDatimeM", &fDatimeM);
      R__insp.InspectMember(fDatimeM, "fDatimeM.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbytesKeys", &fNbytesKeys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbytesName", &fNbytesName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferSize", &fBufferSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekDir", &fSeekDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekParent", &fSeekParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekKeys", &fSeekKeys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKeys", &fKeys);
      TDirectory::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDirectoryFile(void *p) {
      return  p ? new(p) ::TDirectoryFile : new ::TDirectoryFile;
   }
   static void *newArray_TDirectoryFile(Long_t nElements, void *p) {
      return p ? new(p) ::TDirectoryFile[nElements] : new ::TDirectoryFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDirectoryFile(void *p) {
      delete ((::TDirectoryFile*)p);
   }
   static void deleteArray_TDirectoryFile(void *p) {
      delete [] ((::TDirectoryFile*)p);
   }
   static void destruct_TDirectoryFile(void *p) {
      typedef ::TDirectoryFile current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDirectoryFile(TBuffer &buf, void *obj) {
      ((::TDirectoryFile*)obj)->::TDirectoryFile::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDirectoryFile

//______________________________________________________________________________
void TFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFile.
      TClass *R__cl = ::TFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumBuffer", &fSumBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSum2Buffer", &fSum2Buffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesWrite", &fBytesWrite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesReadExtra", &fBytesReadExtra);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBEGIN", &fBEGIN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEND", &fEND);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekFree", &fSeekFree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekInfo", &fSeekInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fD", &fD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbytesFree", &fNbytesFree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbytesInfo", &fNbytesInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWritten", &fWritten);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNProcessIDs", &fNProcessIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadCalls", &fReadCalls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealName", &fRealName);
      R__insp.InspectMember(fRealName, "fRealName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnits", &fUnits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFree", &fFree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassIndex", &fClassIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcessIDs", &fProcessIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArchive", &fArchive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCacheRead", &fCacheRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCacheWrite", &fCacheWrite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArchiveOffset", &fArchiveOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsArchive", &fIsArchive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoAnchorInName", &fNoAnchorInName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRootFile", &fIsRootFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitDone", &fInitDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMustFlush", &fMustFlush);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAsyncHandle", &fAsyncHandle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsyncOpenStatus", &fAsyncOpenStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
      R__insp.InspectMember(fUrl, "fUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfoCache", &fInfoCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOpenPhases", &fOpenPhases);
      TDirectoryFile::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFile(void *p) {
      return  p ? new(p) ::TFile : new ::TFile;
   }
   static void *newArray_TFile(Long_t nElements, void *p) {
      return p ? new(p) ::TFile[nElements] : new ::TFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFile(void *p) {
      delete ((::TFile*)p);
   }
   static void deleteArray_TFile(void *p) {
      delete [] ((::TFile*)p);
   }
   static void destruct_TFile(void *p) {
      typedef ::TFile current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFile(TBuffer &buf, void *obj) {
      ((::TFile*)obj)->::TFile::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFile

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

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

//______________________________________________________________________________
void TFileCacheRead::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFileCacheRead.
      TClass *R__cl = ::TFileCacheRead::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferSizeMin", &fBufferSizeMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferSize", &fBufferSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferLen", &fBufferLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsyncReading", &fAsyncReading);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNseek", &fNseek);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNtot", &fNtot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNb", &fNb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekSize", &fSeekSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeek", &fSeek);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeekSort", &fSeekSort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeekIndex", &fSeekIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeekLen", &fSeekLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeekSortLen", &fSeekSortLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeekPos", &fSeekPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLen", &fLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuffer", &fBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsSorted", &fIsSorted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsTransferred", &fIsTransferred);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFileCacheRead(void *p) {
      return  p ? new(p) ::TFileCacheRead : new ::TFileCacheRead;
   }
   static void *newArray_TFileCacheRead(Long_t nElements, void *p) {
      return p ? new(p) ::TFileCacheRead[nElements] : new ::TFileCacheRead[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFileCacheRead(void *p) {
      delete ((::TFileCacheRead*)p);
   }
   static void deleteArray_TFileCacheRead(void *p) {
      delete [] ((::TFileCacheRead*)p);
   }
   static void destruct_TFileCacheRead(void *p) {
      typedef ::TFileCacheRead current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFileCacheRead

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

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

//______________________________________________________________________________
void TFileCacheWrite::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFileCacheWrite.
      TClass *R__cl = ::TFileCacheWrite::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekStart", &fSeekStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferSize", &fBufferSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNtot", &fNtot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuffer", &fBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRecursive", &fRecursive);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFileCacheWrite(void *p) {
      return  p ? new(p) ::TFileCacheWrite : new ::TFileCacheWrite;
   }
   static void *newArray_TFileCacheWrite(Long_t nElements, void *p) {
      return p ? new(p) ::TFileCacheWrite[nElements] : new ::TFileCacheWrite[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFileCacheWrite(void *p) {
      delete ((::TFileCacheWrite*)p);
   }
   static void deleteArray_TFileCacheWrite(void *p) {
      delete [] ((::TFileCacheWrite*)p);
   }
   static void destruct_TFileCacheWrite(void *p) {
      typedef ::TFileCacheWrite current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFileCacheWrite

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> fFirst;
      R__b >> fLast;
      R__b.CheckByteCount(R__s, R__c, TFree::IsA());
   } else {
      R__c = R__b.WriteVersion(TFree::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << fFirst;
      R__b << fLast;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TFree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFree.
      TClass *R__cl = ::TFree::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);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFree(void *p) {
      return  p ? new(p) ::TFree : new ::TFree;
   }
   static void *newArray_TFree(Long_t nElements, void *p) {
      return p ? new(p) ::TFree[nElements] : new ::TFree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFree(void *p) {
      delete ((::TFree*)p);
   }
   static void deleteArray_TFree(void *p) {
      delete [] ((::TFree*)p);
   }
   static void destruct_TFree(void *p) {
      typedef ::TFree current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFree(TBuffer &buf, void *obj) {
      ((::TFree*)obj)->::TFree::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFree

//______________________________________________________________________________
void TKey::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TKey.
      TClass *R__cl = ::TKey::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbytes", &fNbytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fObjlen", &fObjlen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDatime", &fDatime);
      R__insp.InspectMember(fDatime, "fDatime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeylen", &fKeylen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCycle", &fCycle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekKey", &fSeekKey);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeekPdir", &fSeekPdir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeft", &fLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuffer", &fBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufferRef", &fBufferRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPidOffset", &fPidOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMotherDir", &fMotherDir);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TKey(void *p) {
      return  p ? new(p) ::TKey : new ::TKey;
   }
   static void *newArray_TKey(Long_t nElements, void *p) {
      return p ? new(p) ::TKey[nElements] : new ::TKey[nElements];
   }
   // Wrapper around operator delete
   static void delete_TKey(void *p) {
      delete ((::TKey*)p);
   }
   static void deleteArray_TKey(void *p) {
      delete [] ((::TKey*)p);
   }
   static void destruct_TKey(void *p) {
      typedef ::TKey current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TKey(TBuffer &buf, void *obj) {
      ((::TKey*)obj)->::TKey::Streamer(buf);
   }
} // end of namespace ROOT for class ::TKey

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

   TNamed::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TKeyMapFile(void *p) {
      return  p ? new(p) ::TKeyMapFile : new ::TKeyMapFile;
   }
   static void *newArray_TKeyMapFile(Long_t nElements, void *p) {
      return p ? new(p) ::TKeyMapFile[nElements] : new ::TKeyMapFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TKeyMapFile(void *p) {
      delete ((::TKeyMapFile*)p);
   }
   static void deleteArray_TKeyMapFile(void *p) {
      delete [] ((::TKeyMapFile*)p);
   }
   static void destruct_TKeyMapFile(void *p) {
      typedef ::TKeyMapFile current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TKeyMapFile(TBuffer &buf, void *obj) {
      ((::TKeyMapFile*)obj)->::TKeyMapFile::Streamer(buf);
   }
} // end of namespace ROOT for class ::TKeyMapFile

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TMapFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMapFile.
      TClass *R__cl = ::TMapFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFd", &fFd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fName", &fName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOption", &fOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMmallocDesc", &fMmallocDesc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaseAddr", &fBaseAddr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      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(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrowseList", &fBrowseList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWritable", &fWritable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSemaphore", &fSemaphore);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fhSemaphore", &fhSemaphore);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGetting", &fGetting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWritten", &fWritten);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumBuffer", &fSumBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSum2Buffer", &fSum2Buffer);
      TObject::ShowMembers(R__insp);
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMapRec(void *p) {
      delete ((::TMapRec*)p);
   }
   static void deleteArray_TMapRec(void *p) {
      delete [] ((::TMapRec*)p);
   }
   static void destruct_TMapRec(void *p) {
      typedef ::TMapRec current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMapRec

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

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

//______________________________________________________________________________
void TArchiveFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TArchiveFile.
      TClass *R__cl = ::TArchiveFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArchiveName", &fArchiveName);
      R__insp.InspectMember(fArchiveName, "fArchiveName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemberName", &fMemberName);
      R__insp.InspectMember(fMemberName, "fMemberName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemberIndex", &fMemberIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMembers", &fMembers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurMember", &fCurMember);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TArchiveFile(void *p) {
      delete ((::TArchiveFile*)p);
   }
   static void deleteArray_TArchiveFile(void *p) {
      delete [] ((::TArchiveFile*)p);
   }
   static void destruct_TArchiveFile(void *p) {
      typedef ::TArchiveFile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TArchiveFile

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

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

//______________________________________________________________________________
void TArchiveMember::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TArchiveMember.
      TClass *R__cl = ::TArchiveMember::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(), "fComment", &fComment);
      R__insp.InspectMember(fComment, "fComment.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModTime", &fModTime);
      R__insp.InspectMember(fModTime, "fModTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPosition", &fPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilePosition", &fFilePosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCsize", &fCsize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDsize", &fDsize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirectory", &fDirectory);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArchiveMember(void *p) {
      return  p ? new(p) ::TArchiveMember : new ::TArchiveMember;
   }
   static void *newArray_TArchiveMember(Long_t nElements, void *p) {
      return p ? new(p) ::TArchiveMember[nElements] : new ::TArchiveMember[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArchiveMember(void *p) {
      delete ((::TArchiveMember*)p);
   }
   static void deleteArray_TArchiveMember(void *p) {
      delete [] ((::TArchiveMember*)p);
   }
   static void destruct_TArchiveMember(void *p) {
      typedef ::TArchiveMember current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TArchiveMember

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

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

//______________________________________________________________________________
void TZIPFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TZIPFile.
      TClass *R__cl = ::TZIPFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirPos", &fDirPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirSize", &fDirSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirOffset", &fDirOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fComment", &fComment);
      R__insp.InspectMember(fComment, "fComment.");
      TArchiveFile::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TZIPFile(void *p) {
      return  p ? new(p) ::TZIPFile : new ::TZIPFile;
   }
   static void *newArray_TZIPFile(Long_t nElements, void *p) {
      return p ? new(p) ::TZIPFile[nElements] : new ::TZIPFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TZIPFile(void *p) {
      delete ((::TZIPFile*)p);
   }
   static void deleteArray_TZIPFile(void *p) {
      delete [] ((::TZIPFile*)p);
   }
   static void destruct_TZIPFile(void *p) {
      typedef ::TZIPFile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TZIPFile

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

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

//______________________________________________________________________________
void TZIPMember::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TZIPMember.
      TClass *R__cl = ::TZIPMember::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLocal", &fLocal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalLen", &fLocalLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobal", &fGlobal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGlobalLen", &fGlobalLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCRC32", &fCRC32);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAttrInt", &fAttrInt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAttrExt", &fAttrExt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      TArchiveMember::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TZIPMember(void *p) {
      return  p ? new(p) ::TZIPMember : new ::TZIPMember;
   }
   static void *newArray_TZIPMember(Long_t nElements, void *p) {
      return p ? new(p) ::TZIPMember[nElements] : new ::TZIPMember[nElements];
   }
   // Wrapper around operator delete
   static void delete_TZIPMember(void *p) {
      delete ((::TZIPMember*)p);
   }
   static void deleteArray_TZIPMember(void *p) {
      delete [] ((::TZIPMember*)p);
   }
   static void destruct_TZIPMember(void *p) {
      typedef ::TZIPMember current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TZIPMember

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

   TObject::Streamer(R__b);
}

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

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

//______________________________________________________________________________
void TStreamerInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStreamerInfo.
      TClass *R__cl = ::TStreamerInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckSum", &fCheckSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassVersion", &fClassVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOnFileClassVersion", &fOnFileClassVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdata", &fNdata);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewType", &fNewType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLength", &fLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElem", &fElem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComp", &fComp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &fElements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldVersion", &fOldVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVirtualInfoLoc", &fNVirtualInfoLoc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVirtualInfoLoc", &fVirtualInfoLoc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLiveCount", &fLiveCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadObjectWise", &fReadObjectWise);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadMemberWise", &fReadMemberWise);
      TVirtualStreamerInfo::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerInfo(void *p) {
      return  p ? new(p) ::TStreamerInfo : new ::TStreamerInfo;
   }
   static void *newArray_TStreamerInfo(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerInfo[nElements] : new ::TStreamerInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerInfo(void *p) {
      delete ((::TStreamerInfo*)p);
   }
   static void deleteArray_TStreamerInfo(void *p) {
      delete [] ((::TStreamerInfo*)p);
   }
   static void destruct_TStreamerInfo(void *p) {
      typedef ::TStreamerInfo current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerInfo(TBuffer &buf, void *obj) {
      ((::TStreamerInfo*)obj)->::TStreamerInfo::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerInfo

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCollectionProxyFactory(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionProxyFactory : new ::TCollectionProxyFactory;
   }
   static void *newArray_TCollectionProxyFactory(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionProxyFactory[nElements] : new ::TCollectionProxyFactory[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCollectionProxyFactory(void *p) {
      delete ((::TCollectionProxyFactory*)p);
   }
   static void deleteArray_TCollectionProxyFactory(void *p) {
      delete [] ((::TCollectionProxyFactory*)p);
   }
   static void destruct_TCollectionProxyFactory(void *p) {
      typedef ::TCollectionProxyFactory current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCollectionProxyFactory

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGenCollectionProxycLcLValue(void *p) {
      delete ((::TGenCollectionProxy::Value*)p);
   }
   static void deleteArray_TGenCollectionProxycLcLValue(void *p) {
      delete [] ((::TGenCollectionProxy::Value*)p);
   }
   static void destruct_TGenCollectionProxycLcLValue(void *p) {
      typedef ::TGenCollectionProxy::Value current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGenCollectionProxy::Value

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGenCollectionProxycLcLMethod(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGenCollectionProxy::Method : new ::TGenCollectionProxy::Method;
   }
   static void *newArray_TGenCollectionProxycLcLMethod(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGenCollectionProxy::Method[nElements] : new ::TGenCollectionProxy::Method[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGenCollectionProxycLcLMethod(void *p) {
      delete ((::TGenCollectionProxy::Method*)p);
   }
   static void deleteArray_TGenCollectionProxycLcLMethod(void *p) {
      delete [] ((::TGenCollectionProxy::Method*)p);
   }
   static void destruct_TGenCollectionProxycLcLMethod(void *p) {
      typedef ::TGenCollectionProxy::Method current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGenCollectionProxy::Method

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCollectionStreamer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionStreamer : new ::TCollectionStreamer;
   }
   static void *newArray_TCollectionStreamer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionStreamer[nElements] : new ::TCollectionStreamer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCollectionStreamer(void *p) {
      delete ((::TCollectionStreamer*)p);
   }
   static void deleteArray_TCollectionStreamer(void *p) {
      delete [] ((::TCollectionStreamer*)p);
   }
   static void destruct_TCollectionStreamer(void *p) {
      typedef ::TCollectionStreamer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCollectionStreamer

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCollectionClassStreamer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionClassStreamer : new ::TCollectionClassStreamer;
   }
   static void *newArray_TCollectionClassStreamer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionClassStreamer[nElements] : new ::TCollectionClassStreamer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCollectionClassStreamer(void *p) {
      delete ((::TCollectionClassStreamer*)p);
   }
   static void deleteArray_TCollectionClassStreamer(void *p) {
      delete [] ((::TCollectionClassStreamer*)p);
   }
   static void destruct_TCollectionClassStreamer(void *p) {
      typedef ::TCollectionClassStreamer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCollectionClassStreamer

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCollectionMemberStreamer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionMemberStreamer : new ::TCollectionMemberStreamer;
   }
   static void *newArray_TCollectionMemberStreamer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCollectionMemberStreamer[nElements] : new ::TCollectionMemberStreamer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCollectionMemberStreamer(void *p) {
      delete ((::TCollectionMemberStreamer*)p);
   }
   static void deleteArray_TCollectionMemberStreamer(void *p) {
      delete [] ((::TCollectionMemberStreamer*)p);
   }
   static void destruct_TCollectionMemberStreamer(void *p) {
      typedef ::TCollectionMemberStreamer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCollectionMemberStreamer

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

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

} // namespace TStreamerInfoActions
//______________________________________________________________________________
      namespace TStreamerInfoActions {
void TConfiguredAction::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStreamerInfoActions::TConfiguredAction.
      TClass *R__cl = ::TStreamerInfoActions::TConfiguredAction::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAction", &fAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVecPtrLoopAction", &fVecPtrLoopAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLoopAction", &fLoopAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConfiguration", &fConfiguration);
      TObject::ShowMembers(R__insp);
}

} // namespace TStreamerInfoActions
namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerInfoActionscLcLTConfiguredAction(void *p) {
      return  p ? new(p) ::TStreamerInfoActions::TConfiguredAction : new ::TStreamerInfoActions::TConfiguredAction;
   }
   static void *newArray_TStreamerInfoActionscLcLTConfiguredAction(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerInfoActions::TConfiguredAction[nElements] : new ::TStreamerInfoActions::TConfiguredAction[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerInfoActionscLcLTConfiguredAction(void *p) {
      delete ((::TStreamerInfoActions::TConfiguredAction*)p);
   }
   static void deleteArray_TStreamerInfoActionscLcLTConfiguredAction(void *p) {
      delete [] ((::TStreamerInfoActions::TConfiguredAction*)p);
   }
   static void destruct_TStreamerInfoActionscLcLTConfiguredAction(void *p) {
      typedef ::TStreamerInfoActions::TConfiguredAction current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStreamerInfoActions::TConfiguredAction

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

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

} // namespace TStreamerInfoActions
//______________________________________________________________________________
      namespace TStreamerInfoActions {
void TActionSequence::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStreamerInfoActions::TActionSequence.
      TClass *R__cl = ::TStreamerInfoActions::TActionSequence::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamerInfo", &fStreamerInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLoopConfig", &fLoopConfig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActions", (void*)&fActions);
      R__insp.InspectMember("TStreamerInfoActions::ActionContainer_t", (void*)&fActions, "fActions.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace TStreamerInfoActions
namespace ROOT {
   // Wrapper around operator delete
   static void delete_TStreamerInfoActionscLcLTActionSequence(void *p) {
      delete ((::TStreamerInfoActions::TActionSequence*)p);
   }
   static void deleteArray_TStreamerInfoActionscLcLTActionSequence(void *p) {
      delete [] ((::TStreamerInfoActions::TActionSequence*)p);
   }
   static void destruct_TStreamerInfoActionscLcLTActionSequence(void *p) {
      typedef ::TStreamerInfoActions::TActionSequence current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStreamerInfoActions::TActionSequence

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TStreamerInfoActionscLcLTConfiguration(void *p) {
      delete ((::TStreamerInfoActions::TConfiguration*)p);
   }
   static void deleteArray_TStreamerInfoActionscLcLTConfiguration(void *p) {
      delete [] ((::TStreamerInfoActions::TConfiguration*)p);
   }
   static void destruct_TStreamerInfoActionscLcLTConfiguration(void *p) {
      typedef ::TStreamerInfoActions::TConfiguration current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStreamerInfoActions::TConfiguration

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualArray(void *p) {
      delete ((::TVirtualArray*)p);
   }
   static void deleteArray_TVirtualArray(void *p) {
      delete [] ((::TVirtualArray*)p);
   }
   static void destruct_TVirtualArray(void *p) {
      typedef ::TVirtualArray current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualArray

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualObject(void *p) {
      delete ((::TVirtualObject*)p);
   }
   static void deleteArray_TVirtualObject(void *p) {
      delete [] ((::TVirtualObject*)p);
   }
   static void destruct_TVirtualObject(void *p) {
      typedef ::TVirtualObject current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualObject

/********************************************************
* io/io/src/G__IO.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__IO();

extern "C" void G__set_cpp_environmentG__IO() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TArchiveFile.h");
  G__add_compiledheader("TBufferFile.h");
  G__add_compiledheader("TCollectionProxyFactory.h");
  G__add_compiledheader("TContainerConverters.h");
  G__add_compiledheader("TDirectoryFile.h");
  G__add_compiledheader("TEmulatedCollectionProxy.h");
  G__add_compiledheader("TEmulatedMapProxy.h");
  G__add_compiledheader("TFileCacheRead.h");
  G__add_compiledheader("TFileCacheWrite.h");
  G__add_compiledheader("TFile.h");
  G__add_compiledheader("TFree.h");
  G__add_compiledheader("TGenCollectionProxy.h");
  G__add_compiledheader("TGenCollectionStreamer.h");
  G__add_compiledheader("TKey.h");
  G__add_compiledheader("TKeyMapFile.h");
  G__add_compiledheader("TLockFile.h");
  G__add_compiledheader("TMakeProject.h");
  G__add_compiledheader("TMapFile.h");
  G__add_compiledheader("TStreamerInfoActions.h");
  G__add_compiledheader("TStreamerInfo.h");
  G__add_compiledheader("TVirtualArray.h");
  G__add_compiledheader("TVirtualCollectionIterators.h");
  G__add_compiledheader("TVirtualObject.h");
  G__add_compiledheader("TZIPFile.h");
  G__cpp_reset_tagtableG__IO();
}
#include <new>
extern "C" int G__cpp_dllrevG__IO() { return(30051515); }

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

/* TVirtualArray */
static int G__G__IO_89_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVirtualArray((TClass*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVirtualArray((TClass*) G__int(libp->para[0]), (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__IOLN_TVirtualArray));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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


/* TStreamerInfoActions */

/* TStreamerInfoActions::TActionSequence */
static int G__G__IO_91_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerInfoActions::TActionSequence* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerInfoActions::TActionSequence((TVirtualStreamerInfo*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TStreamerInfoActions::TActionSequence((TVirtualStreamerInfo*) G__int(libp->para[0]), (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__IOLN_TStreamerInfoActionscLcLTActionSequence));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_91_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerInfoActions::TActionSequence*) G__getstructoffset())->AddAction(*(TStreamerInfoActions::TConfiguredAction*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_91_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerInfoActions::TActionSequence*) G__getstructoffset())->AddToOffset((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_91_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TStreamerInfoActions::TActionSequence*) G__getstructoffset())->CreateCopy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_91_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerInfoActions::TActionSequence::CreateReadMemberWiseActions((TVirtualStreamerInfo*) G__int(libp->para[0]), *(TVirtualCollectionProxy*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_91_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TStreamerInfoActions::TActionSequence*) G__getstructoffset())->CreateSubSequence(*(vector<Int_t>*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TStreamerInfoActions::TActionSequence G__TTStreamerInfoActionscLcLTActionSequence;
static int G__G__IO_91_0_22(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[] (TStreamerInfoActions::TActionSequence*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerInfoActions::TActionSequence*) (soff+(sizeof(TStreamerInfoActions::TActionSequence)*i)))->~G__TTStreamerInfoActionscLcLTActionSequence();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerInfoActions::TActionSequence*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerInfoActions::TActionSequence*) (soff))->~G__TTStreamerInfoActionscLcLTActionSequence();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__IO_111_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFile(
(const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TFile(
(const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFile(
(const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TFile(
(const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFile((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TFile((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__IOLN_TFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TFile*) G__getstructoffset())->CreateKey((TDirectory*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TFile*) G__getstructoffset())->CreateKey((TDirectory*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__IO_111_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TFile*) G__getstructoffset())->GetCompressionFactor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetEND());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_111_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TFile*) G__getstructoffset())->ResetErrno();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__IO_111_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetBytesRead());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetBytesReadExtra());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetBytesWritten());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__IO_111_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFile*) G__getstructoffset())->GetRecordHeader((char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__IO_111_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetRelOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetSeekFree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetSeekInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFile*) G__getstructoffset())->GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__IO_111_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFile*) G__getstructoffset())->MakeFree((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__IO_111_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TFile*) G__getstructoffset())->MakeProject((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TFile*) G__getstructoffset())->MakeProject((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TFile*) G__getstructoffset())->MakeProject((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__IO_111_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFile*) G__getstructoffset())->ReadBufferAsync((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_111_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFile*) G__getstructoffset())->ReadBuffer((char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFile*) G__getstructoffset())->ReadBuffers((char*) G__int(libp->para[0]), (Long64_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__IO_111_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TFile*) G__getstructoffset())->Seek((Long64_t) G__Longlong(libp->para[0]), (TFile::ERelativeTo) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TFile*) G__getstructoffset())->Seek((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__IO_111_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TFile*) G__getstructoffset())->SetOffset((Long64_t) G__Longlong(libp->para[0]), (TFile::ERelativeTo) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TFile*) G__getstructoffset())->SetOffset((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__IO_111_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((TFile*) G__getstructoffset())->WriteProcessID((TProcessID*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_111_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) TFile::AsyncOpen((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) TFile::AsyncOpen((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TFile::AsyncOpen((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TFile::AsyncOpen((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TFile::AsyncOpen((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) TFile::Open((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) TFile::Open((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TFile::Open((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TFile::Open((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TFile::Open((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFile::Open((TFileOpenHandle*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TFile::GetType((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (TString*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TFile::GetType((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) TFile::GetType((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFile::GetAsyncOpenStatus((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFile::GetAsyncOpenStatus((TFileOpenHandle*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFile::GetEndpointUrl((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) TFile::GetFileBytesRead());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) TFile::GetFileBytesWritten());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__IO_111_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TFile::SetFileBytesRead((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TFile::SetFileBytesRead();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TFile::SetFileBytesWritten((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TFile::SetFileBytesWritten();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__IO_111_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) TFile::GetFileCounter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFile::IncrementFileCounter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) TFile::SetCacheFileDir((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TFile::SetCacheFileDir((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) TFile::SetCacheFileDir((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_111_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) TFile::ShrinkCacheFileDir((Long64_t) G__Longlong(libp->para[0]), (Long_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) TFile::ShrinkCacheFileDir((Long64_t) G__Longlong(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) TFile::Cp((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) TFile::Cp((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TFile::Cp((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TFile::SetOpenTimeout((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TFile::GetOpenTimeout());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TFile::SetOnlyStaged((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_111_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TFile::GetOnlyStaged());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__IO_112_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime* pobj;
         const TDatime xobj = ((const TArchiveMember*) G__getstructoffset())->GetModTime();
         pobj = new TDatime(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__IO_112_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArchiveMember*) G__getstructoffset())->GetPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_112_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArchiveMember*) G__getstructoffset())->GetFilePosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_112_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArchiveMember*) G__getstructoffset())->GetCompressedSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_112_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArchiveMember*) G__getstructoffset())->GetDecompressedSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


/* TArchiveFile */
static int G__G__IO_113_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TArchiveFile*) G__getstructoffset())->OpenArchive());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__IO_113_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArchiveFile*) G__getstructoffset())->GetMemberFilePosition());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__IO_113_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TArchiveFile::Open((const char*) G__int(libp->para[0]), (TFile*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TArchiveFile G__TTArchiveFile;
static int G__G__IO_113_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TArchiveFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TArchiveFile*) (soff+(sizeof(TArchiveFile)*i)))->~G__TTArchiveFile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TArchiveFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TArchiveFile*) (soff))->~G__TTArchiveFile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

static int G__G__IO_114_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerInfo*) G__getstructoffset())->GetDataMemberOffset((TDataMember*) G__int(libp->para[0]), libp->para[1].ref ? *(TMemberStreamer**) libp->para[1].ref : *(TMemberStreamer**) (void*) (&G__Mlong(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__IO_114_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 75, (long) ((const TStreamerInfo*) G__getstructoffset())->GetMethods());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__IO_114_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TStreamerInfo*) G__getstructoffset())->GetValueClones((TClonesArray*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TStreamerInfo*) G__getstructoffset())->GetValueSTL((TVirtualCollectionProxy*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TStreamerInfo*) G__getstructoffset())->GetValueSTLP((TVirtualCollectionProxy*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__IO_114_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((const TStreamerInfo*) G__getstructoffset())->PrintValueSTL((const char*) G__int(libp->para[0]), (TVirtualCollectionProxy*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((const TStreamerInfo*) G__getstructoffset())->PrintValueSTL((const char*) G__int(libp->para[0]), (TVirtualCollectionProxy*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerInfo*) G__getstructoffset())->ReadBufferClones(*(TBuffer*) libp->para[0].ref, (TClonesArray*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerInfo*) G__getstructoffset())->ReadBufferSTL(*(TBuffer*) libp->para[0].ref, (TVirtualCollectionProxy*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerInfo*) G__getstructoffset())->WriteBuffer(*(TBuffer*) libp->para[0].ref, (char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerInfo*) G__getstructoffset())->WriteBufferClones(*(TBuffer*) libp->para[0].ref, (TClonesArray*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerInfo*) G__getstructoffset())->WriteBufferSTL(*(TBuffer*) libp->para[0].ref, (TVirtualCollectionProxy*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_114_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerInfo*) G__getstructoffset())->WriteBufferSTLPtrs(*(TBuffer*) libp->para[0].ref, (TVirtualCollectionProxy*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__IO_116_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBufferFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBufferFile((TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TBufferFile((TBuffer::EMode) 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__IOLN_TBufferFile));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TCollectionProxyFactory */
static int G__G__IO_172_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenEmulatedProxy((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_172_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenEmulatedClassStreamer((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_172_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenEmulatedMemberStreamer((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_172_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenExplicitProxy(*(ROOT::TCollectionProxyInfo*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_172_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenExplicitStreamer(*(ROOT::TCollectionProxyInfo*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_172_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenExplicitClassStreamer(*(ROOT::TCollectionProxyInfo*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_172_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCollectionProxyFactory::GenExplicitMemberStreamer(*(ROOT::TCollectionProxyInfo*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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


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

static int G__G__IO_173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGenCollectionProxy* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGenCollectionProxy(*(type_info*) libp->para[0].ref, (size_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGenCollectionProxy(*(type_info*) libp->para[0].ref, (size_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__IOLN_TGenCollectionProxy));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TGenCollectionProxy G__TTGenCollectionProxy;
static int G__G__IO_173_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGenCollectionProxy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGenCollectionProxy*) (soff+(sizeof(TGenCollectionProxy)*i)))->~G__TTGenCollectionProxy();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGenCollectionProxy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGenCollectionProxy*) (soff))->~G__TTGenCollectionProxy();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__G__IO_175_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGenCollectionProxy::Value*) G__getstructoffset())->DeleteItem((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_175_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGenCollectionProxy::Value*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGenCollectionProxy::Value G__TTGenCollectionProxycLcLValue;
static int G__G__IO_175_0_5(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[] (TGenCollectionProxy::Value*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGenCollectionProxy::Value*) (soff+(sizeof(TGenCollectionProxy::Value)*i)))->~G__TTGenCollectionProxycLcLValue();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGenCollectionProxy::Value*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGenCollectionProxy::Value*) (soff))->~G__TTGenCollectionProxycLcLValue();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__IO_177_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGenCollectionProxy::Method* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGenCollectionProxy::Method((TGenCollectionProxy::Method::Call_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGenCollectionProxy::Method((TGenCollectionProxy::Method::Call_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__IOLN_TGenCollectionProxycLcLMethod));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef TGenCollectionProxy::Method G__TTGenCollectionProxycLcLMethod;
static int G__G__IO_177_0_5(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[] (TGenCollectionProxy::Method*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGenCollectionProxy::Method*) (soff+(sizeof(TGenCollectionProxy::Method)*i)))->~G__TTGenCollectionProxycLcLMethod();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGenCollectionProxy::Method*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGenCollectionProxy::Method*) (soff))->~G__TTGenCollectionProxycLcLMethod();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

// automatic destructor
typedef TEmulatedCollectionProxy G__TTEmulatedCollectionProxy;
static int G__G__IO_190_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEmulatedCollectionProxy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEmulatedCollectionProxy*) (soff+(sizeof(TEmulatedCollectionProxy)*i)))->~G__TTEmulatedCollectionProxy();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEmulatedCollectionProxy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEmulatedCollectionProxy*) (soff))->~G__TTEmulatedCollectionProxy();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

static int G__G__IO_191_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCollectionStreamer*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (TClass*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

static int G__G__IO_202_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TKey*) G__getstructoffset())->GetCycle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_202_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime& obj = ((const TKey*) G__getstructoffset())->GetDatime();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_202_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TKey*) G__getstructoffset())->GetKeep());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__IO_202_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TKey*) G__getstructoffset())->GetSeekKey());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_202_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TKey*) G__getstructoffset())->GetSeekPdir());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__IO_202_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKey*) G__getstructoffset())->ReadBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_202_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKey*) G__getstructoffset())->ReadKeyBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__IO_204_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime& obj = ((const TDirectoryFile*) G__getstructoffset())->GetCreationDate();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_204_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime& obj = ((const TDirectoryFile*) G__getstructoffset())->GetModificationDate();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

static int G__G__IO_213_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFileCacheRead* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFileCacheRead((TFile*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TFileCacheRead((TFile*) 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__IOLN_TFileCacheRead));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__IO_213_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFileCacheRead*) G__getstructoffset())->GetUnzipBuffer((char**) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__IO_213_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileCacheRead*) G__getstructoffset())->Prefetch((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__IO_213_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFileCacheRead*) G__getstructoffset())->ReadBufferExt((char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_213_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFileCacheRead*) G__getstructoffset())->ReadBuffer((char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TFileCacheRead G__TTFileCacheRead;
static int G__G__IO_213_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFileCacheRead*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFileCacheRead*) (soff+(sizeof(TFileCacheRead)*i)))->~G__TTFileCacheRead();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFileCacheRead*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFileCacheRead*) (soff))->~G__TTFileCacheRead();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__IO_214_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFileCacheWrite* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFileCacheWrite((TFile*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TFileCacheWrite((TFile*) 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__IOLN_TFileCacheWrite));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__IO_214_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFileCacheWrite*) G__getstructoffset())->ReadBuffer((char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_214_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFileCacheWrite*) G__getstructoffset())->WriteBuffer((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__IO_223_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TFree*) G__getstructoffset())->AddFree((TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_223_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFree*) G__getstructoffset())->FillBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_223_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFree*) G__getstructoffset())->GetFirst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_223_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFree*) G__getstructoffset())->GetLast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_223_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFree*) G__getstructoffset())->ReadBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TFree G__TTFree;
static int G__G__IO_223_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFree*) (soff+(sizeof(TFree)*i)))->~G__TTFree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFree*) (soff))->~G__TTFree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMapFile */
static int G__G__IO_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMapFile::operator delete((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__IO_234_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TMapFile*) G__getstructoffset())->cd((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TMapFile*) G__getstructoffset())->cd());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__IO_234_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) TMapFile::Create((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TMapFile::Create((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TMapFile::Create((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TMapFile::Create((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_234_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMapFile::WhichMapFile((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


/* TLockFile */
static int G__G__IO_236_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLockFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLockFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TLockFile((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 TLockFile((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TLockFile((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__IOLN_TLockFile));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__IO_252_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((const TMapRec*) G__getstructoffset())->GetName((Long_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((const TMapRec*) G__getstructoffset())->GetName());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_252_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((const TMapRec*) G__getstructoffset())->GetClassName((Long_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((const TMapRec*) G__getstructoffset())->GetClassName());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__IO_252_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TMapRec*) G__getstructoffset())->GetNext((Long_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TMapRec*) G__getstructoffset())->GetNext());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

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

static int G__G__IO_261_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerInfoActions::TConfiguration*) G__getstructoffset())->AddToOffset((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_261_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TStreamerInfoActions::TConfiguration*) G__getstructoffset())->Copy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_261_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TStreamerInfoActions::TConfiguration*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_261_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TStreamerInfoActions::TConfiguration*) G__getstructoffset())->PrintDebug(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef TStreamerInfoActions::TConfiguration G__TTStreamerInfoActionscLcLTConfiguration;
static int G__G__IO_261_0_8(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[] (TStreamerInfoActions::TConfiguration*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerInfoActions::TConfiguration*) (soff+(sizeof(TStreamerInfoActions::TConfiguration)*i)))->~G__TTStreamerInfoActionscLcLTConfiguration();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerInfoActions::TConfiguration*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerInfoActions::TConfiguration*) (soff))->~G__TTStreamerInfoActionscLcLTConfiguration();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

static int G__G__IO_263_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TStreamerInfoActions::TConfiguredAction*) G__getstructoffset())->PrintDebug(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_263_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerInfoActions::TConfiguredAction*) G__getstructoffset())->operator()(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_263_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerInfoActions::TConfiguredAction*) G__getstructoffset())->operator()(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__IO_263_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerInfoActions::TConfiguredAction*) G__getstructoffset())->operator()(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TStreamerInfoActions::TLoopConfiguration*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TStreamerInfoActions::TConfiguredAction G__TTStreamerInfoActionscLcLTConfiguredAction;
static int G__G__IO_263_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStreamerInfoActions::TConfiguredAction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerInfoActions::TConfiguredAction*) (soff+(sizeof(TStreamerInfoActions::TConfiguredAction)*i)))->~G__TTStreamerInfoActionscLcLTConfiguredAction();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerInfoActions::TConfiguredAction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerInfoActions::TConfiguredAction*) (soff))->~G__TTStreamerInfoActionscLcLTConfiguredAction();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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


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

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

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

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

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

static int G__G__IO_278_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TZIPMember*) G__getstructoffset())->GetLocalLen());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__IO_278_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TZIPMember*) G__getstructoffset())->GetGlobalLen());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

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

/* TVirtualArray */

/* TStreamerInfoActions */

/* TStreamerInfoActions::TActionSequence */

/* TFile */

/* TArchiveMember */

/* TArchiveFile */

/* TStreamerInfo */

/* TBufferFile */

/* TCollectionProxyFactory */

/* TGenCollectionProxy */

/* TGenCollectionProxy::Value */

/* TGenCollectionProxy::Method */

/* TEmulatedCollectionProxy */

/* TCollectionStreamer */

/* TCollectionClassStreamer */

/* TCollectionMemberStreamer */

/* TKey */

/* TDirectoryFile */

/* TEmulatedMapProxy */

/* TFileCacheRead */

/* TFileCacheWrite */

/* TFree */

/* TMapFile */

/* TKeyMapFile */

/* TLockFile */

/* TMapRec */

/* TStreamerInfoActions::TConfiguration */

/* TStreamerInfoActions::TConfiguredAction */

/* TVirtualObject */

/* TZIPMember */

/* TZIPFile */

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

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

size_t G__get_sizep2memfuncG__IO()
{
  G__Sizep2memfuncG__IO 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__IO() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence))) {
     TStreamerInfoActions::TActionSequence *G__Lderived;
     G__Lderived=(TStreamerInfoActions::TActionSequence*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TFile))) {
     TFile *G__Lderived;
     G__Lderived=(TFile*)0x1000;
     {
       TDirectoryFile *G__Lpbase=(TDirectoryFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFile),G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFile),G__get_linked_tagnum(&G__G__IOLN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFile),G__get_linked_tagnum(&G__G__IOLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TArchiveMember))) {
     TArchiveMember *G__Lderived;
     G__Lderived=(TArchiveMember*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TArchiveMember),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TArchiveFile))) {
     TArchiveFile *G__Lderived;
     G__Lderived=(TArchiveFile*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TArchiveFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo))) {
     TStreamerInfo *G__Lderived;
     G__Lderived=(TStreamerInfo*)0x1000;
     {
       TVirtualStreamerInfo *G__Lpbase=(TVirtualStreamerInfo*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo),G__get_linked_tagnum(&G__G__IOLN_TVirtualStreamerInfo),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo),G__get_linked_tagnum(&G__G__IOLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TBufferFile))) {
     TBufferFile *G__Lderived;
     G__Lderived=(TBufferFile*)0x1000;
     {
       TBuffer *G__Lpbase=(TBuffer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TBufferFile),G__get_linked_tagnum(&G__G__IOLN_TBuffer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TBufferFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy))) {
     TGenCollectionProxy *G__Lderived;
     G__Lderived=(TGenCollectionProxy*)0x1000;
     {
       TVirtualCollectionProxy *G__Lpbase=(TVirtualCollectionProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy),G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy))) {
     TEmulatedCollectionProxy *G__Lderived;
     G__Lderived=(TEmulatedCollectionProxy*)0x1000;
     {
       TGenCollectionProxy *G__Lpbase=(TGenCollectionProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy),G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualCollectionProxy *G__Lpbase=(TVirtualCollectionProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy),G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer))) {
     TCollectionClassStreamer *G__Lderived;
     G__Lderived=(TCollectionClassStreamer*)0x1000;
     {
       TClassStreamer *G__Lpbase=(TClassStreamer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer),G__get_linked_tagnum(&G__G__IOLN_TClassStreamer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollectionStreamer *G__Lpbase=(TCollectionStreamer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer),G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer))) {
     TCollectionMemberStreamer *G__Lderived;
     G__Lderived=(TCollectionMemberStreamer*)0x1000;
     {
       TMemberStreamer *G__Lpbase=(TMemberStreamer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer),G__get_linked_tagnum(&G__G__IOLN_TMemberStreamer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollectionStreamer *G__Lpbase=(TCollectionStreamer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer),G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TKey))) {
     TKey *G__Lderived;
     G__Lderived=(TKey*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TKey),G__get_linked_tagnum(&G__G__IOLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TKey),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile))) {
     TDirectoryFile *G__Lderived;
     G__Lderived=(TDirectoryFile*)0x1000;
     {
       TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile),G__get_linked_tagnum(&G__G__IOLN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile),G__get_linked_tagnum(&G__G__IOLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy))) {
     TEmulatedMapProxy *G__Lderived;
     G__Lderived=(TEmulatedMapProxy*)0x1000;
     {
       TEmulatedCollectionProxy *G__Lpbase=(TEmulatedCollectionProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy),G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGenCollectionProxy *G__Lpbase=(TGenCollectionProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy),G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TVirtualCollectionProxy *G__Lpbase=(TVirtualCollectionProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy),G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead))) {
     TFileCacheRead *G__Lderived;
     G__Lderived=(TFileCacheRead*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite))) {
     TFileCacheWrite *G__Lderived;
     G__Lderived=(TFileCacheWrite*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TFree))) {
     TFree *G__Lderived;
     G__Lderived=(TFree*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TFree),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TMapFile))) {
     TMapFile *G__Lderived;
     G__Lderived=(TMapFile*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TMapFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile))) {
     TKeyMapFile *G__Lderived;
     G__Lderived=(TKeyMapFile*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile),G__get_linked_tagnum(&G__G__IOLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TLockFile))) {
     TLockFile *G__Lderived;
     G__Lderived=(TLockFile*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TLockFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction))) {
     TStreamerInfoActions::TConfiguredAction *G__Lderived;
     G__Lderived=(TStreamerInfoActions::TConfiguredAction*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TZIPMember))) {
     TZIPMember *G__Lderived;
     G__Lderived=(TZIPMember*)0x1000;
     {
       TArchiveMember *G__Lpbase=(TArchiveMember*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPMember),G__get_linked_tagnum(&G__G__IOLN_TArchiveMember),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPMember),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__IOLN_TZIPFile))) {
     TZIPFile *G__Lderived;
     G__Lderived=(TZIPFile*)0x1000;
     {
       TArchiveFile *G__Lpbase=(TArchiveFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPFile),G__get_linked_tagnum(&G__G__IOLN_TArchiveFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPFile),G__get_linked_tagnum(&G__G__IOLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

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

   /* Setting up typedef entry */
   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("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ReAllocCharFun_t",89,-1,0,-1);
   G__setnewtype(-1,"char *(*ReAllocCharFun_t)(char*, size_t, size_t);",0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("InfoList_t",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,G__get_linked_tagnum(&G__G__IOLN_TBufferFile));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEboolcOallocatorlEboolgRsPgR));
   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__IOLN_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__IOLN_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__IOLN_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__IOLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Info_t",117,G__get_linked_tagnum(&G__G__IOLN_type_info),257,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Call_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod));
   G__setnewtype(-1,"void* (*Call_t)(void*);",0);
   G__search_typename2("Env_t",117,G__get_linked_tagnum(&G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironlEcharoB64cBgR),0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EnvironBase_t",117,G__get_linked_tagnum(&G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironBase),0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TStaging*>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGenCollectionProxy::TStaging*>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Staged_t",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR),0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,"Collection of pre-allocated staged array for associative containers.",0);
   G__search_typename2("vector<EnvironBase_t*>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::TCollectionProxyInfo::EnvironBase*>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Proxies_t",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR),0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Sizing_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,"void (*Sizing_t)(void *obj, size_t size);",0);
   G__search_typename2("Feedfunc_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,"void* (*Feedfunc_t)(void *from, void *to, size_t size);",0);
   G__search_typename2("ArrIterfunc_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__setnewtype(-1,"void* (*ArrIterfunc_t)(void *from, size_t size);",0);
   G__search_typename2("Proxy_t",117,G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy),0,G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Info_t",117,G__get_linked_tagnum(&G__G__IOLN_type_info),257,G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Cont_t",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR),0,G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PCont_t",85,G__get_linked_tagnum(&G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR),0,G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Next_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TStreamerInfoAction_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   G__setnewtype(-1,"Int_t (*TStreamerInfoAction_t)(TBuffer &buf, void *obj, const TConfiguration *conf);",0);
   G__search_typename2("TStreamerInfoVecPtrLoopAction_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   G__setnewtype(-1,"Int_t (*TStreamerInfoVecPtrLoopAction_t)(TBuffer &buf, void *iter, const void *end, const TConfiguration *conf);",0);
   G__search_typename2("TStreamerInfoLoopAction_t",89,-1,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   G__setnewtype(-1,"Int_t (*TStreamerInfoLoopAction_t)(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *conf);",0);
   G__search_typename2("vector<TConfiguredAction>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TStreamerInfoActions::TConfiguredAction>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ActionContainer_t",117,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR),0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__IOLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

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

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

   /* TVirtualArray */
static void G__setup_memvarTVirtualArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TVirtualArray));
   { TVirtualArray *p; p=(TVirtualArray*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fClass)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__IOLN_TClassRef),-1,-1,1,"fClass=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSize)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),67,0,0,-1,-1,-1,1,"fArray=",0,"[fSize] ");
   }
   G__tag_memvar_reset();
}


   /* TStreamerInfoActions */
static void G__setup_memvarTStreamerInfoActions(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   {
   }
   G__tag_memvar_reset();
}


   /* TStreamerInfoActions::TActionSequence */
static void G__setup_memvarTStreamerInfoActionscLcLTActionSequence(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence));
   { TStreamerInfoActions::TActionSequence *p; p=(TStreamerInfoActions::TActionSequence*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fStreamerInfo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__IOLN_TVirtualStreamerInfo),-1,-1,1,"fStreamerInfo=",0,"StreamerInfo used to derive these actions.");
   G__memvar_setup((void*)((long)(&p->fLoopConfig)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTLoopConfiguration),-1,-1,1,"fLoopConfig=",0,"If this is a bundle of memberwise streaming action, this configures the looping");
   G__memvar_setup((void*)((long)(&p->fActions)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR),G__defined_typename("ActionContainer_t"),-1,1,"fActions=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFile */
static void G__setup_memvarTFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TFile));
   { TFile *p; p=(TFile*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus),-1,-2,1,G__FastAllocString(2048).Format("kAOSNotAsync=%lldLL",(long long)TFile::kAOSNotAsync).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus),-1,-2,1,G__FastAllocString(2048).Format("kAOSFailure=%lldLL",(long long)TFile::kAOSFailure).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus),-1,-2,1,G__FastAllocString(2048).Format("kAOSInProgress=%lldLL",(long long)TFile::kAOSInProgress).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus),-1,-2,1,G__FastAllocString(2048).Format("kAOSSuccess=%lldLL",(long long)TFile::kAOSSuccess).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEOpenTimeOut),-1,-2,1,G__FastAllocString(2048).Format("kInstantTimeout=%lldLL",(long long)TFile::kInstantTimeout).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEOpenTimeOut),-1,-2,1,G__FastAllocString(2048).Format("kEternalTimeout=%lldLL",(long long)TFile::kEternalTimeout).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSumBuffer=",0,"Sum of buffer sizes of objects written so far");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSum2Buffer=",0,"Sum of squares of buffer sizes of objects written so far");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBytesWrite=",0,"Number of bytes written to this file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBytesRead=",0,"Number of bytes read from this file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBytesReadExtra=",0,"Number of extra bytes (overhead) read by the readahead buffer");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBEGIN=",0,"First used byte in file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEND=",0,"Last used byte in file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekFree=",0,"Location on disk of free segments structure");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekInfo=",0,"Location on disk of StreamerInfo record");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fD=",0,"File descriptor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersion=",0,"File format version");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCompress=",0,"Compression level from 0(not compressed) to 9 (max compression)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbytesFree=",0,"Number of bytes for free segments structure");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbytesInfo=",0,"Number of bytes for StreamerInfo record");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWritten=",0,"Number of objects written so far");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNProcessIDs=",0,"Number of TProcessID written to this file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fReadCalls=",0,"Number of read calls ( not counting the cache calls )");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fRealName=",0,"Effective real file name (not original url)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fOption=",0,"File options");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fUnits=",0,"Number of bytes for file pointers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TList),-1,-1,2,"fFree=",0,"Free segments linked list table");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TArrayC),-1,-1,2,"fClassIndex=",0,"!Index of TStreamerInfo classes written to this file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TObjArray),-1,-1,2,"fProcessIDs=",0,"!Array of pointers to TProcessIDs");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fOffset=",0,"!Seek offset cache");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TArchiveFile),-1,-1,2,"fArchive=",0,"!Archive file from which we read this file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead),-1,-1,2,"fCacheRead=",0,"!Pointer to the read cache (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite),-1,-1,2,"fCacheWrite=",0,"!Pointer to the write cache (if any)");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fArchiveOffset=",0,"!Offset at which file starts in archive");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsArchive=",0,"!True if this is a pure archive file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNoAnchorInName=",0,"!True if we don't want to force the anchor to be appended to the file name");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsRootFile=",0,"!True is this is a ROOT file, raw file otherwise");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInitDone=",0,"!True if the file has been initialized");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMustFlush=",0,"!True if the file buffers must be flushed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFileOpenHandle),-1,-1,2,"fAsyncHandle=",0,"!For proper automatic cleanup");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus),-1,-1,2,"fAsyncOpenStatus=",0,"!Status of an asynchronous open request");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TUrl),-1,-1,2,"fUrl=",0,"!URL of file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TList),-1,-1,2,"fInfoCache=",0,"!Cached list of the streamer infos in this file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TList),-1,-1,2,"fOpenPhases=",0,"!Time info about open phases");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TList),-1,-2,2,"fgAsyncOpenRequests=",0,"List of handles for pending open requests");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-2,2,"fgCacheFileDir=",0,"Directory where to locally stage files");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgCacheFileDisconnected=",0,"Indicates, we trust in the files in the cache dir without stat on the cached file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgCacheFileForce=",0,"Indicates, to force all READ to CACHEREAD");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgOpenTimeout=",0,"Timeout for open operations in ms  - 0 corresponds to blocking i/o");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgOnlyStaged=",0,"Before the file is opened, it is checked, that the file is staged, if not, the open fails");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,2,"fgBytesWrite=",0,"Number of bytes written by all TFile objects");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,2,"fgBytesRead=",0,"Number of bytes read by all TFile objects");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,2,"fgFileCounter=",0,"Counter for all opened files");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgReadCalls=",0,"Number of bytes read from all TFile objects");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgReadaheadSize=",0,"Readahead buffer size");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgReadInfo=",0,"if true (default) ReadStreamerInfo is called when opening a file");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kRecovered=%lldLL",(long long)TFile::kRecovered).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kHasReferences=%lldLL",(long long)TFile::kHasReferences).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kDevNull=%lldLL",(long long)TFile::kDevNull).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kWriteError=%lldLL",(long long)TFile::kWriteError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kBinaryFile=%lldLL",(long long)TFile::kBinaryFile).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kRedirected=%lldLL",(long long)TFile::kRedirected).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLERelativeTo),-1,-2,1,G__FastAllocString(2048).Format("kBeg=%lldLL",(long long)TFile::kBeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLERelativeTo),-1,-2,1,G__FastAllocString(2048).Format("kCur=%lldLL",(long long)TFile::kCur).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLERelativeTo),-1,-2,1,G__FastAllocString(2048).Format("kEnd=%lldLL",(long long)TFile::kEnd).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kStartBigFile=%lldLL",(long long)TFile::kStartBigFile).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEFileType),-1,-2,1,G__FastAllocString(2048).Format("kDefault=%lldLL",(long long)TFile::kDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEFileType),-1,-2,1,G__FastAllocString(2048).Format("kLocal=%lldLL",(long long)TFile::kLocal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEFileType),-1,-2,1,G__FastAllocString(2048).Format("kNet=%lldLL",(long long)TFile::kNet).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEFileType),-1,-2,1,G__FastAllocString(2048).Format("kWeb=%lldLL",(long long)TFile::kWeb).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEFileType),-1,-2,1,G__FastAllocString(2048).Format("kFile=%lldLL",(long long)TFile::kFile).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArchiveMember */
static void G__setup_memvarTArchiveMember(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TArchiveMember));
   { TArchiveMember *p; p=(TArchiveMember*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fName=",0,"Name of member");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fComment=",0,"Comment field");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TDatime),-1,-1,2,"fModTime=",0,"Modification time");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fPosition=",0,"Byte position in archive");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFilePosition=",0,"Byte position in archive where member data starts");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fCsize=",0,"Compressed size");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fDsize=",0,"Decompressed size");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDirectory=",0,"Flag indicating this is a directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArchiveFile */
static void G__setup_memvarTArchiveFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TArchiveFile));
   { TArchiveFile *p; p=(TArchiveFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fArchiveName=",0,"Archive file name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fMemberName=",0,"Sub-file name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMemberIndex=",0,"Index of sub-file in archive");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFile),-1,-1,2,"fFile=",0,"File stream used to access the archive");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TObjArray),-1,-1,2,"fMembers=",0,"Members in this archive");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TArchiveMember),-1,-1,2,"fCurMember=",0,"Current archive member");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerInfo */
static void G__setup_memvarTStreamerInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo));
   { TStreamerInfo *p; p=(TStreamerInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCheckSum=",0,"checksum of original class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fClassVersion=",0,"Class version identifier");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOnFileClassVersion=",0,"!Class version identifier as stored on file.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumber=",0,"!Unique identifier");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdata=",0,"!number of optmized types");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,"!size of the persistent class");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fType=",0,"![fNdata]");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNewType=",0,"![fNdata]");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOffset=",0,"![fNdata]");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLength=",0,"![fNdata]");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fElem=",0,"![fNdata]");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fMethod=",0,"![fNdata]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLTCompInfo),-1,-1,4,"fComp=",0,"![fNdata] additional info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-1,4,"fClass=",0,"!pointer to class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TObjArray),-1,-1,4,"fElements=",0,"Array of TStreamerElements");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Version_t"),-1,4,"fOldVersion=",0,"! Version of the TStreamerInfo object read from the file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNVirtualInfoLoc=",0,"! Number of virtual info location to update.");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fVirtualInfoLoc=",0,"![fNVirtualInfoLoc] Location of the pointer to the TStreamerInfo inside the object (when emulated)");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fLiveCount=",0,"! Number of outstanding pointer to this StreamerInfo.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence),-1,-1,4,"fReadObjectWise=",0,"! List of action resulting from the compilation.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence),-1,-1,4,"fReadMemberWise=",0,"! List of action resulting from the compilation for use in member wise streaming.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgCount=",0,"Number of TStreamerInfo instances");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerElement),-1,-2,4,"fgElement=",0,"Pointer to current TStreamerElement");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCannotOptimize=%lldLL",(long long)TStreamerInfo::kCannotOptimize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIgnoreTObjectStreamer=%lldLL",(long long)TStreamerInfo::kIgnoreTObjectStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kRecovered=%lldLL",(long long)TStreamerInfo::kRecovered).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNeedCheck=%lldLL",(long long)TStreamerInfo::kNeedCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsCompiled=%lldLL",(long long)TStreamerInfo::kIsCompiled).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kBase=%lldLL",(long long)TStreamerInfo::kBase).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kOffsetL=%lldLL",(long long)TStreamerInfo::kOffsetL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kOffsetP=%lldLL",(long long)TStreamerInfo::kOffsetP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCounter=%lldLL",(long long)TStreamerInfo::kCounter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCharStar=%lldLL",(long long)TStreamerInfo::kCharStar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kChar=%lldLL",(long long)TStreamerInfo::kChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kShort=%lldLL",(long long)TStreamerInfo::kShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kInt=%lldLL",(long long)TStreamerInfo::kInt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kLong=%lldLL",(long long)TStreamerInfo::kLong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kFloat=%lldLL",(long long)TStreamerInfo::kFloat).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kDouble=%lldLL",(long long)TStreamerInfo::kDouble).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kDouble32=%lldLL",(long long)TStreamerInfo::kDouble32).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kUChar=%lldLL",(long long)TStreamerInfo::kUChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kUShort=%lldLL",(long long)TStreamerInfo::kUShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kUInt=%lldLL",(long long)TStreamerInfo::kUInt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kULong=%lldLL",(long long)TStreamerInfo::kULong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kBits=%lldLL",(long long)TStreamerInfo::kBits).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kLong64=%lldLL",(long long)TStreamerInfo::kLong64).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kULong64=%lldLL",(long long)TStreamerInfo::kULong64).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kBool=%lldLL",(long long)TStreamerInfo::kBool).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kFloat16=%lldLL",(long long)TStreamerInfo::kFloat16).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kObject=%lldLL",(long long)TStreamerInfo::kObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAny=%lldLL",(long long)TStreamerInfo::kAny).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kObjectp=%lldLL",(long long)TStreamerInfo::kObjectp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kObjectP=%lldLL",(long long)TStreamerInfo::kObjectP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kTString=%lldLL",(long long)TStreamerInfo::kTString).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kTObject=%lldLL",(long long)TStreamerInfo::kTObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kTNamed=%lldLL",(long long)TStreamerInfo::kTNamed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAnyp=%lldLL",(long long)TStreamerInfo::kAnyp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAnyP=%lldLL",(long long)TStreamerInfo::kAnyP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAnyPnoVT=%lldLL",(long long)TStreamerInfo::kAnyPnoVT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSTLp=%lldLL",(long long)TStreamerInfo::kSTLp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSkip=%lldLL",(long long)TStreamerInfo::kSkip).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSkipL=%lldLL",(long long)TStreamerInfo::kSkipL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSkipP=%lldLL",(long long)TStreamerInfo::kSkipP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kConv=%lldLL",(long long)TStreamerInfo::kConv).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kConvL=%lldLL",(long long)TStreamerInfo::kConvL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kConvP=%lldLL",(long long)TStreamerInfo::kConvP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSTL=%lldLL",(long long)TStreamerInfo::kSTL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSTLstring=%lldLL",(long long)TStreamerInfo::kSTLstring).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kStreamer=%lldLL",(long long)TStreamerInfo::kStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kStreamLoop=%lldLL",(long long)TStreamerInfo::kStreamLoop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCache=%lldLL",(long long)TStreamerInfo::kCache).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kArtificial=%lldLL",(long long)TStreamerInfo::kArtificial).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCacheNew=%lldLL",(long long)TStreamerInfo::kCacheNew).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCacheDelete=%lldLL",(long long)TStreamerInfo::kCacheDelete).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kMissing=%lldLL",(long long)TStreamerInfo::kMissing).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBufferFile */
static void G__setup_memvarTBufferFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TBufferFile));
   { TBufferFile *p; p=(TBufferFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMapCount=",0,"Number of objects or classes in map");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMapSize=",0,"Default size of map");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDisplacement=",0,"Value to be added to the map offsets");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fPidOffset=",0,"Offset to be added to the pid index in this key/buffer.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TExMap),-1,-1,2,"fMap=",0,"Map containing object,offset pairs for reading/writing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TExMap),-1,-1,2,"fClassMap=",0,"Map containing object,class pairs for reading");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo),-1,-1,2,"fInfo=",0,"Pointer to TStreamerInfo object writing/reading the buffer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),G__defined_typename("InfoList_t"),-1,2,"fInfoStack=",0,"Stack of pointers to the TStreamerInfos");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgMapSize=",0,"Default map size for all TBuffer objects");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kMapSize=%lldLL",(long long)TBufferFile::kMapSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kStreamedMemberWise=%lldLL",(long long)TBufferFile::kStreamedMemberWise).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNotDecompressed=%lldLL",(long long)TBufferFile::kNotDecompressed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTextBasedStreaming=%lldLL",(long long)TBufferFile::kTextBasedStreaming).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kUser1=%lldLL",(long long)TBufferFile::kUser1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kUser2=%lldLL",(long long)TBufferFile::kUser2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TBufferFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kUser3=%lldLL",(long long)TBufferFile::kUser3).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCollectionProxyFactory */
static void G__setup_memvarTCollectionProxyFactory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory));
   { TCollectionProxyFactory *p; p=(TCollectionProxyFactory*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TGenCollectionProxy */
static void G__setup_memvarTGenCollectionProxy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   { TGenCollectionProxy *p; p=(TGenCollectionProxy*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBIT_ISSTRING=%lldLL",(long long)TGenCollectionProxy::kBIT_ISSTRING).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBIT_ISTSTRING=%lldLL",(long long)TGenCollectionProxy::kBIT_ISTSTRING).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBOOL_t=%lldLL",(long long)TGenCollectionProxy::kBOOL_t).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TObjArray),-1,-1,2,"fReadMemberWise=",0,"Array of bundle of TStreamerInfoActions to stream out (read)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),G__defined_typename("map<std::string,TObjArray*>"),-1,2,"fConversionReadMemberWise=",0,"Array of bundle of TStreamerInfoActions to stream out (read) derived from another class.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_string),-1,-1,2,"fName=",0,"Name of the class being proxied.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPointers=",0,"Flag to indicate if containee has pointers (key or value)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod),-1,-1,2,"fClear=",0,"Method cache for container accessors: clear container");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod),-1,-1,2,"fSize=",0,"Container accessors: size of container");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("Sizing_t"),-1,2,"fResize=",0,"Container accessors: resize container");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod),-1,-1,2,"fFirst=",0,"Container accessors: generic iteration: first");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod),-1,-1,2,"fNext=",0,"Container accessors: generic iteration: next");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ArrIterfunc_t"),-1,2,"fConstruct=",0,"Container accessors: block construct");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("Sizing_t"),-1,2,"fDestruct=",0,"Container accessors: block destruct");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("Feedfunc_t"),-1,2,"fFeed=",0,"Container accessors: block feed");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod),-1,-1,2,"fCollect=",0,"Method to collect objects from container");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod0),-1,-1,2,"fCreateEnv=",0,"Method to allocate an Environment holder.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue),-1,-1,2,"fValue=",0,"Descriptor of the container value type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue),-1,-1,2,"fVal=",0,"Descriptor of the Value_type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue),-1,-1,2,"fKey=",0,"Descriptor of the key_type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironBase),G__defined_typename("EnvironBase_t"),-1,2,"fEnv=",0,"Address of the currently proxied object");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fValOffset=",0,"Offset from key to value (in maps)");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fValDiff=",0,"Offset between two consecutive value_types (memory layout).");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR),G__defined_typename("Proxies_t"),-1,2,"fProxyList=",0,"Stack of recursive proxies");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR),G__defined_typename("Proxies_t"),-1,2,"fProxyKept=",0,"Optimization: Keep proxies once they were created");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR),G__defined_typename("Staged_t"),-1,2,"fStaged=",0,"Optimization: Keep staged array once they were created");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fSTL_type=",0,"STL container type");
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__IOLN_type_info),G__defined_typename("Info_t"),-1,2,"fTypeinfo=",0,"Type information");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-1,2,"fOnFileClass=",0,"On file class");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CreateIterators_t"),-1,2,"fFunctionCreateIterators=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DeleteTwoIterators_t"),-1,2,"fFunctionDeleteTwoIterators=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGenCollectionProxy::Value */
static void G__setup_memvarTGenCollectionProxycLcLValue(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue));
   { TGenCollectionProxy::Value *p; p=(TGenCollectionProxy::Value*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fCtor)-(long)(p)),89,0,0,-1,G__defined_typename("NewFunc_t"),-1,1,"fCtor=",0,"Method cache for containee constructor");
   G__memvar_setup((void*)((long)(&p->fDtor)-(long)(p)),89,0,0,-1,G__defined_typename("DesFunc_t"),-1,1,"fDtor=",0,"Method cache for containee destructor");
   G__memvar_setup((void*)((long)(&p->fDelete)-(long)(p)),89,0,0,-1,G__defined_typename("DelFunc_t"),-1,1,"fDelete=",0,"Method cache for containee delete");
   G__memvar_setup((void*)((long)(&p->fCase)-(long)(p)),104,0,0,-1,-1,-1,1,"fCase=",0,"type of data of Value_type");
   G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__IOLN_TClassRef),-1,-1,1,"fType=",0,"TClass reference of Value_type in collection");
   G__memvar_setup((void*)((long)(&p->fKind)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__G__IOLN_EDataType),-1,-1,1,"fKind=",0,"kind of ROOT-fundamental type");
   G__memvar_setup((void*)((long)(&p->fSize)-(long)(p)),104,0,0,-1,G__defined_typename("size_t"),-1,1,"fSize=",0,"fSize of the contained object");
   }
   G__tag_memvar_reset();
}


   /* TGenCollectionProxy::Method */
static void G__setup_memvarTGenCollectionProxycLcLMethod(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod));
   { TGenCollectionProxy::Method *p; p=(TGenCollectionProxy::Method*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->call)-(long)(p)),89,0,0,-1,G__defined_typename("Call_t"),-1,1,"call=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEmulatedCollectionProxy */
static void G__setup_memvarTEmulatedCollectionProxy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy));
   { TEmulatedCollectionProxy *p; p=(TEmulatedCollectionProxy*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TCollectionStreamer */
static void G__setup_memvarTCollectionStreamer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer));
   { TCollectionStreamer *p; p=(TCollectionStreamer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy),-1,-1,2,"fStreamer=",0,"/ Pointer to worker streamer");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCollectionClassStreamer */
static void G__setup_memvarTCollectionClassStreamer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer));
   { TCollectionClassStreamer *p; p=(TCollectionClassStreamer*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TCollectionMemberStreamer */
static void G__setup_memvarTCollectionMemberStreamer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer));
   { TCollectionMemberStreamer *p; p=(TCollectionMemberStreamer*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TKey */
static void G__setup_memvarTKey(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TKey));
   { TKey *p; p=(TKey*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersion=",0,"Key version identifier");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbytes=",0,"Number of bytes for the object on file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fObjlen=",0,"Length of uncompressed object in bytes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TDatime),-1,-1,2,"fDatime=",0,"Date/Time of insertion in file");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fKeylen=",0,"Number of bytes for the key itself");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fCycle=",0,"Cycle number");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekKey=",0,"Location of object on file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekPdir=",0,"Location of parent directory on file");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fClassName=",0,"Object Class name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLeft=",0,"Number of bytes left in current segment");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBuffer=",0,"Object buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TBuffer),-1,-1,2,"fBufferRef=",0,"Pointer to the TBuffer object");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fPidOffset=",0,"! Offset to be added to the pid index in this key/buffer.  This is actually saved in the high bits of fSeekPdir");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TDirectory),-1,-1,2,"fMotherDir=",0,"! pointer to mother directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDirectoryFile */
static void G__setup_memvarTDirectoryFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile));
   { TDirectoryFile *p; p=(TDirectoryFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fModified=",0,"true if directory has been modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fWritable=",0,"true if directory is writable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TDatime),-1,-1,2,"fDatimeC=",0,"Date and time when directory is created");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TDatime),-1,-1,2,"fDatimeM=",0,"Date and time of last modification");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbytesKeys=",0,"Number of bytes for the keys");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbytesName=",0,"Number of bytes in TNamed at creation time");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferSize=",0,"Default buffer size to create new TKeys");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekDir=",0,"Location of directory on file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekParent=",0,"Location of parent directory on file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekKeys=",0,"Location of Keys record on file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFile),-1,-1,2,"fFile=",0,"pointer to current file in memory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TList),-1,-1,2,"fKeys=",0,"Pointer to keys list in memory");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TDirectoryFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCloseDirectory=%lldLL",(long long)TDirectoryFile::kCloseDirectory).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEmulatedMapProxy */
static void G__setup_memvarTEmulatedMapProxy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy));
   { TEmulatedMapProxy *p; p=(TEmulatedMapProxy*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TFileCacheRead */
static void G__setup_memvarTFileCacheRead(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead));
   { TFileCacheRead *p; p=(TFileCacheRead*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferSizeMin=",0,"Original size of fBuffer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferSize=",0,"Allocated size of fBuffer (at a given time)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferLen=",0,"Current buffer length (<= fBufferSize)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAsyncReading=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNseek=",0,"Number of blocks to be prefetched");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNtot=",0,"Total size of prefetched blocks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNb=",0,"Number of long buffers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeekSize=",0,"Allocated size of fSeek");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeek=",0,"[fNseek] Position on file of buffers to be prefetched");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekSort=",0,"[fNseek] Position on file of buffers to be prefetched (sorted)");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeekIndex=",0,"[fNseek] sorted index table of fSeek");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fPos=",0,"[fNb] start of long buffers");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeekLen=",0,"[fNseek] Length of buffers to be prefetched");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeekSortLen=",0,"[fNseek] Length of buffers to be prefetched (sorted)");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeekPos=",0,"[fNseek] Position of sorted blocks in fBuffer");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLen=",0,"[fNb] Length of long buffers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFile),-1,-1,2,"fFile=",0,"Pointer to file");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBuffer=",0,"[fBufferSize] buffer of contiguous prefetched blocks");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsSorted=",0,"True if fSeek array is sorted");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsTransferred=",0,"True when fBuffer contains something valid");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFileCacheWrite */
static void G__setup_memvarTFileCacheWrite(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite));
   { TFileCacheWrite *p; p=(TFileCacheWrite*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSeekStart=",0,"Seek value of first block in cache");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferSize=",0,"Allocated size of fBuffer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNtot=",0,"Total size of cached blocks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFile),-1,-1,2,"fFile=",0,"Pointer to file");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBuffer=",0,"[fBufferSize] buffer of contiguous prefetched blocks");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRecursive=",0,"flag to avoid recursive calls");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFree */
static void G__setup_memvarTFree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TFree));
   { TFree *p; p=(TFree*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFirst=",0,"First free word of segment");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fLast=",0,"Last free word of segment");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMapFile */
static void G__setup_memvarTMapFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TMapFile));
   { TMapFile *p; p=(TMapFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFd=",0,"Descriptor of mapped file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVersion=",0,"ROOT version (or -1 for shadow map file)");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fName=",0,"Name of mapped file");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fTitle=",0,"Title of mapped file");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fOption=",0,"Directory creation options");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fMmallocDesc=",0,"Pointer to mmalloc descriptor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fBaseAddr=",0,"Base address of mapped memory region");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,"Original start size of memory mapped region");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TMapRec),-1,-1,4,"fFirst=",0,"List of streamed objects is shared memory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TMapRec),-1,-1,4,"fLast=",0,"Last object in list of shared objects");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fOffset=",0,"Offset in bytes for region mapped by reader");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TDirectory),-1,-1,4,"fDirectory=",0,"Pointer to directory associated to this mapfile");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TList),-1,-1,4,"fBrowseList=",0,"List of KeyMapFile objects");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fWritable=",0,"TRUE if mapped file opened in RDWR mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSemaphore=",0,"Modification semaphore (or getpid() for WIN32)");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fhSemaphore=",0,"HANDLE of WIN32 Mutex object to implement semaphore");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TObject),-1,-1,4,"fGetting=",0,"Don't deadlock in update mode, when from Get() Add() is called");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWritten=",0,"Number of objects written sofar");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumBuffer=",0,"Sum of buffer sizes of objects written sofar");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSum2Buffer=",0,"Sum of squares of buffer sizes of objects written so far");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgMapAddress=",0,"Map to this address, set address via SetMapAddress()");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-2,4,"fgMmallocDesc=",0,"Used in Close() and operator delete()");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TMapFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDefaultMapSize=%lldLL",(long long)TMapFile::kDefaultMapSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TKeyMapFile */
static void G__setup_memvarTKeyMapFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile));
   { TKeyMapFile *p; p=(TKeyMapFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TMapFile),-1,-1,4,"fMapFile=",0,"pointer to map file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLockFile */
static void G__setup_memvarTLockFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TLockFile));
   { TLockFile *p; p=(TLockFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fPath=",0,"path to file holding the lock");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMapRec */
static void G__setup_memvarTMapRec(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TMapRec));
   { TMapRec *p; p=(TMapRec*)0x1000; if (p) { }
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fName=",0,"object name");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fClassName=",0,"class name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TObject),-1,-1,4,"fObject=",0,"pointer to original object");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fBuffer=",0,"buffer containing object of class name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBufSize=",0,"buffer size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TMapRec),-1,-1,4,"fNext=",0,"next MapRec in list");
   }
   G__tag_memvar_reset();
}


   /* TStreamerInfoActions::TConfiguration */
static void G__setup_memvarTStreamerInfoActionscLcLTConfiguration(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration));
   { TStreamerInfoActions::TConfiguration *p; p=(TStreamerInfoActions::TConfiguration*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fInfo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__IOLN_TVirtualStreamerInfo),-1,-1,1,"fInfo=",0,"TStreamerInfo form which the action is derived");
   G__memvar_setup((void*)((long)(&p->fElemId)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fElemId=",0,"Identifier of the TStreamerElement");
   G__memvar_setup((void*)((long)(&p->fOffset)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fOffset=",0,"Offset within the object");
   G__memvar_setup((void*)((long)(&p->fLength)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fLength=",0,"Number of element in a fixed length array.");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerInfoActions::TConfiguredAction */
static void G__setup_memvarTStreamerInfoActionscLcLTConfiguredAction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction));
   { TStreamerInfoActions::TConfiguredAction *p; p=(TStreamerInfoActions::TConfiguredAction*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fAction)-(long)(p)),89,0,0,-1,G__defined_typename("TStreamerInfoAction_t"),-1,1,"fAction=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fVecPtrLoopAction)-(long)(p)),89,0,0,-1,G__defined_typename("TStreamerInfoVecPtrLoopAction_t"),-1,1,"fVecPtrLoopAction=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fLoopAction)-(long)(p)),89,0,0,-1,G__defined_typename("TStreamerInfoLoopAction_t"),-1,1,"fLoopAction=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fConfiguration)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration),-1,-1,1,"fConfiguration=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualObject */
static void G__setup_memvarTVirtualObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TVirtualObject));
   { TVirtualObject *p; p=(TVirtualObject*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fClass)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__IOLN_TClassRef),-1,-1,1,"fClass=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fObject)-(long)(p)),89,0,0,-1,-1,-1,1,"fObject=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TZIPMember */
static void G__setup_memvarTZIPMember(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPMember));
   { TZIPMember *p; p=(TZIPMember*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fLocal=",0,"Extra file header data");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fLocalLen=",0,"Length of extra file header data");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fGlobal=",0,"Extra directory data");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fGlobalLen=",0,"Length of extra directory data");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCRC32=",0,"CRC-32 for all decompressed data");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fAttrInt=",0,"Internal file attributes");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fAttrExt=",0,"External file attributes");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fMethod=",0,"Compression type");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fLevel=",0,"Compression level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TZIPFile */
static void G__setup_memvarTZIPFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPFile));
   { TZIPFile *p; p=(TZIPFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fDirPos=",0,"Central directory position");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fDirSize=",0,"Central directory size");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fDirOffset=",0,"Central directory offset (from the beginning of the archive)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__IOLN_TString),-1,-1,2,"fComment=",0,"Archive comment");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kARCHIVE_VERSION=20LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_HEADER_MAGIC=33639248LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_HEADER_MAGIC=67324752LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_HEADER_MAGIC=101010256LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kZIP_MAGIC_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kMAX_VAR_LEN=65535LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kMAX_SIZE=-1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_MAGIC_OFF=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_VMADE_OFF=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_VMADE_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_VREQD_OFF=6LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_VREQD_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_FLAG_OFF=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_FLAG_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_METHOD_OFF=10LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_METHOD_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_DATE_OFF=12LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_DATE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_CRC32_OFF=16LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_CRC32_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_CSIZE_OFF=20LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_CSIZE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_USIZE_OFF=24LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_USIZE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_NAMELEN_OFF=28LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_NAMELEN_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_EXTRALEN_OFF=30LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_EXTRALEN_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_COMMENTLEN_OFF=32LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_COMMENTLEN_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_DISK_START_OFF=34LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_DISK_START_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_INT_ATTR_OFF=36LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_INT_ATTR_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_EXT_ATTR_OFF=38LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_EXT_ATTR_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_ENTRY_POS_OFF=42LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_ENTRY_POS_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDIR_HEADER_SIZE=46LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_MAGIC_OFF=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DISK_OFF=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DISK_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DIR_DISK_OFF=6LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DIR_DISK_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DISK_HDRS_OFF=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DISK_HDRS_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_TOTAL_HDRS_OFF=10LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_TOTAL_HDRS_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DIR_SIZE_OFF=12LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DIR_SIZE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DIR_OFFSET_OFF=16LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_DIR_OFFSET_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_COMMENTLEN_OFF=20LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_COMMENTLEN_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kEND_HEADER_SIZE=22LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_MAGIC_OFF=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_VREQD_OFF=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_VREQD_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_FLAG_OFF=6LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_FLAG_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_METHOD_OFF=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_METHOD_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_DATE_OFF=10LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_DATE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_CRC32_OFF=14LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_CRC32_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_CSIZE_OFF=18LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_CSIZE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_USIZE_OFF=22LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_USIZE_LEN=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_NAMELEN_OFF=26LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_NAMELEN_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_EXTRALEN_OFF=28LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_EXTRALEN_LEN=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kENTRY_HEADER_SIZE=30LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kSTORED=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__IOLN_TZIPFilecLcLEZIPConstants),-1,-2,2,"kDEFLATED=8LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__IOLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTVirtualArray(void) {
   /* TVirtualArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TVirtualArray));
   G__memfunc_setup("TVirtualArray",1338,G__G__IO_89_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TVirtualArray), -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 0 - cl h - 'UInt_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__IO_89_0_2, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__IO_89_0_3, 67, -1, -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectAt",1068,G__G__IO_89_0_4, 67, -1, -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TVirtualArray", 1338, G__G__IO_89_0_5, (int) ('i'), G__get_linked_tagnum(&G__G__IOLN_TVirtualArray), -1, 0, 1, 1, 1, 0, "u 'TVirtualArray' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualArray", 1464, G__G__IO_89_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_89_0_7, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TVirtualArray), -1, 1, 1, 1, 1, 0, "u 'TVirtualArray' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerInfoActions(void) {
   /* TStreamerInfoActions */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActions));
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerInfoActionscLcLTActionSequence(void) {
   /* TStreamerInfoActions::TActionSequence */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence));
   G__memfunc_setup("TActionSequence",1515,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TActionSequence",1515,G__G__IO_91_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 2, 1, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info h - 'UInt_t' 0 - maxdata", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAction",871,G__G__IO_91_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TStreamerInfoActions::TConfiguredAction' - 11 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToOffset",1075,G__G__IO_91_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateCopy",1007,G__G__IO_91_0_5, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateReadMemberWiseActions",2705,G__G__IO_91_0_6, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 2, 3, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info u 'TVirtualCollectionProxy' - 1 - proxy", (char*)NULL, (void*) G__func2void( (TStreamerInfoActions::TActionSequence* (*)(TVirtualStreamerInfo*, TVirtualCollectionProxy&))(&TStreamerInfoActions::TActionSequence::CreateReadMemberWiseActions) ), 0);
   G__memfunc_setup("CreateSubSequence",1719,G__G__IO_91_0_7, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - element_ids h - 'size_t' 0 - offset", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__IO_91_0_9, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerInfoActions::TActionSequence::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_91_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfoActions::TActionSequence::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_91_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerInfoActions::TActionSequence::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_91_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerInfoActions::TActionSequence::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_91_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_91_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfoActions::TActionSequence::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_91_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerInfoActions::TActionSequence::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_91_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfoActions::TActionSequence::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_91_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerInfoActions::TActionSequence::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TActionSequence", 1515, G__G__IO_91_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 1, 1, 1, 0, "u 'TStreamerInfoActions::TActionSequence' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TActionSequence", 1641, G__G__IO_91_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_91_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 1, 1, 1, 1, 0, "u 'TStreamerInfoActions::TActionSequence' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFile(void) {
   /* TFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TFile));
   G__memfunc_setup("GetAsyncOpenStatus",1844,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - create", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FlushWriteCache",1505,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBufferViaCache",1738,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBufferViaCache",1881,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"C - - 10 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SysOpen",721,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"C - - 10 - pathname i - 'Int_t' 0 - flags "
"h - 'UInt_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysClose",821,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - fd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysRead",699,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - fd Y - - 0 - buf "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysWrite",842,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - fd Y - - 10 - buf "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysSeek",711,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - fd n - 'Long64_t' 0 - offset "
"i - 'Int_t' 0 - whence", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysStat",731,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"i - 'Int_t' 0 - fd L - 'Long_t' 0 - id "
"N - 'Long64_t' 0 - size L - 'Long_t' 0 - flags "
"L - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysSync",732,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - fd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirCreateEntry",1413,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 2, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirReadKeys",1079,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirWriteKeys",1222,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirWriteHeader",1395,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TFile",468,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 1, 1, 4, 0, "u 'TFile' - 11 - -", "Files cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TFile' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CpProgress",1032,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 4, 0, 
"n - 'Long64_t' 0 - bytesread n - 'Long64_t' 0 - size "
"u 'TStopwatch' - 1 - watch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenFromCache",1274,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 5, 3, 4, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' - "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress "
"i - 'Int_t' 0 '0' netopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFile",468,G__G__IO_111_0_21, 105, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFile",468,G__G__IO_111_0_22, 105, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 4, 1, 1, 0, 
"C - - 10 - fname C - 'Option_t' 10 '\"\"' option "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateKey",893,G__G__IO_111_0_25, 85, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 4, 1, 1, 0, 
"U 'TDirectory' - 0 - mother U 'TObject' - 10 - obj "
"C - - 10 - name i - 'Int_t' 0 - bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateKey",893,G__G__IO_111_0_26, 85, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 5, 1, 1, 0, 
"U 'TDirectory' - 0 - mother Y - - 10 - obj "
"U 'TClass' - 10 - cl C - - 10 - name "
"i - 'Int_t' 0 - bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' namecycle", (char*)NULL, (void*) NULL, 1);
   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("DrawMap",684,G__G__IO_111_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"*\"' keys C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Flush",514,G__G__IO_111_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArchive",994,G__G__IO_111_0_32, 85, G__get_linked_tagnum(&G__G__IOLN_TArchiveFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestBuffer",1288,G__G__IO_111_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBytesToPrefetch",1819,G__G__IO_111_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCacheRead",1136,G__G__IO_111_0_35, 85, G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCacheWrite",1279,G__G__IO_111_0_36, 85, G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassIndex",1294,G__G__IO_111_0_37, 85, G__get_linked_tagnum(&G__G__IOLN_TArrayC), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompressionLevel",1962,G__G__IO_111_0_38, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompressionFactor",2065,G__G__IO_111_0_39, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEND",503,G__G__IO_111_0_40, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrno",806,G__G__IO_111_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetErrno",1033,G__G__IO_111_0_42, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFd",458,G__G__IO_111_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndpointUrl",1428,G__G__IO_111_0_44, 85, G__get_linked_tagnum(&G__G__IOLN_TUrl), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfProcessIDs",1872,G__G__IO_111_0_45, 85, G__get_linked_tagnum(&G__G__IOLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFree",1267,G__G__IO_111_0_46, 85, G__get_linked_tagnum(&G__G__IOLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNfree",784,G__G__IO_111_0_47, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNProcessIDs",1357,G__G__IO_111_0_48, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("GetBytesRead",1187,G__G__IO_111_0_50, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBytesReadExtra",1703,G__G__IO_111_0_51, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBytesWritten",1556,G__G__IO_111_0_52, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReadCalls",1163,G__G__IO_111_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVersion",1030,G__G__IO_111_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRecordHeader",1480,G__G__IO_111_0_55, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - first "
"i - 'Int_t' 0 - maxbytes i - 'Int_t' 1 - nbytes "
"i - 'Int_t' 1 - objlen i - 'Int_t' 1 - keylen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbytesInfo",1313,G__G__IO_111_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbytesFree",1303,G__G__IO_111_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRelOffset",1194,G__G__IO_111_0_58, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeekFree",1066,G__G__IO_111_0_59, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekInfo",1076,G__G__IO_111_0_60, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__IO_111_0_61, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStreamerInfoList",1931,G__G__IO_111_0_62, 85, G__get_linked_tagnum(&G__G__IOLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStreamerInfoCache",1987,G__G__IO_111_0_63, 85, G__get_linked_tagnum(&G__G__IOLN_TList), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementProcessIDs",1924,G__G__IO_111_0_64, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsArchive",894,G__G__IO_111_0_65, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsBinary",801,G__G__IO_111_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRaw",486,G__G__IO_111_0_67, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOpen",590,G__G__IO_111_0_68, 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("MakeFree",768,G__G__IO_111_0_70, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - last", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeProject",1109,G__G__IO_111_0_71, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - dirname C - - 10 '\"*\"' classes "
"C - 'Option_t' 10 '\"new\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Map",286,G__G__IO_111_0_72, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Matches",709,G__G__IO_111_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MustFlush",939,G__G__IO_111_0_74, 103, -1, G__defined_typename("Bool_t"), 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("ReadBufferAsync",1492,G__G__IO_111_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - offs i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_111_0_78, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_111_0_79, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffers",1097,G__G__IO_111_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"C - - 0 - buf N - 'Long64_t' 0 - pos "
"I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFree",766,G__G__IO_111_0_81, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadProcessID",1256,G__G__IO_111_0_82, 85, G__get_linked_tagnum(&G__G__IOLN_TProcessID), -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - pidf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStreamerInfo",1611,G__G__IO_111_0_83, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recover",726,G__G__IO_111_0_84, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReOpen",585,G__G__IO_111_0_85, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Seek",392,G__G__IO_111_0_86, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - offset i 'TFile::ERelativeTo' - 0 'kBeg' pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCacheRead",1148,G__G__IO_111_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFileCacheRead' - 0 - cache", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCacheWrite",1291,G__G__IO_111_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFileCacheWrite' - 0 - cache", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCompressionLevel",1974,G__G__IO_111_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEND",515,G__G__IO_111_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - last", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOffset",915,G__G__IO_111_0_91, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - offset i 'TFile::ERelativeTo' - 0 'kBeg' pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__IO_111_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\">\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetReadCalls",1175,G__G__IO_111_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' readcalls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowStreamerInfo",1648,G__G__IO_111_0_94, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SumBuffer",911,G__G__IO_111_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseCache",769,G__G__IO_111_0_97, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '10' maxCacheSize i - 'Int_t' 0 '0' pageSize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBuffer",1125,G__G__IO_111_0_98, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - buf i - 'Int_t' 0 - len", (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' opt "
"i - 'Int_t' 0 '0' bufsiz", (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' opt "
"i - 'Int_t' 0 '0' bufsiz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFree",909,G__G__IO_111_0_101, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteHeader",1108,G__G__IO_111_0_102, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteProcessID",1399,G__G__IO_111_0_103, 114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 0, "U 'TProcessID' - 0 - pid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteStreamerInfo",1754,G__G__IO_111_0_104, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AsyncOpen",912,G__G__IO_111_0_105, 85, G__get_linked_tagnum(&G__G__IOLN_TFileOpenHandle), -1, 0, 5, 3, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress "
"i - 'Int_t' 0 '0' netopt", (char*)NULL, (void*) G__func2void( (TFileOpenHandle* (*)(const char*, Option_t*, const char*, Int_t, Int_t))(&TFile::AsyncOpen) ), 0);
   G__memfunc_setup("Open",402,G__G__IO_111_0_106, 85, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 5, 3, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress "
"i - 'Int_t' 0 '0' netopt", (char*)NULL, (void*) G__func2void( (TFile* (*)(const char*, Option_t*, const char*, Int_t, Int_t))(&TFile::Open) ), 0);
   G__memfunc_setup("Open",402,G__G__IO_111_0_107, 85, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 1, 3, 1, 0, "U 'TFileOpenHandle' - 0 - handle", (char*)NULL, (void*) G__func2void( (TFile* (*)(TFileOpenHandle*))(&TFile::Open) ), 0);
   G__memfunc_setup("GetType",706,G__G__IO_111_0_108, 105, G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEFileType), -1, 0, 3, 3, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"U 'TString' - 0 '0' prefix", (char*)NULL, (void*) G__func2void( (TFile::EFileType (*)(const char*, Option_t*, TString*))(&TFile::GetType) ), 0);
   G__memfunc_setup("GetAsyncOpenStatus",1844,G__G__IO_111_0_109, 105, G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus), -1, 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (TFile::EAsyncOpenStatus (*)(const char*))(&TFile::GetAsyncOpenStatus) ), 0);
   G__memfunc_setup("GetAsyncOpenStatus",1844,G__G__IO_111_0_110, 105, G__get_linked_tagnum(&G__G__IOLN_TFilecLcLEAsyncOpenStatus), -1, 0, 1, 3, 1, 0, "U 'TFileOpenHandle' - 0 - handle", (char*)NULL, (void*) G__func2void( (TFile::EAsyncOpenStatus (*)(TFileOpenHandle*))(&TFile::GetAsyncOpenStatus) ), 0);
   G__memfunc_setup("GetEndpointUrl",1428,G__G__IO_111_0_111, 85, G__get_linked_tagnum(&G__G__IOLN_TUrl), -1, 0, 1, 3, 1, 1, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (const TUrl* (*)(const char*))(&TFile::GetEndpointUrl) ), 0);
   G__memfunc_setup("GetFileBytesRead",1571,G__G__IO_111_0_112, 110, -1, G__defined_typename("Long64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long64_t (*)())(&TFile::GetFileBytesRead) ), 0);
   G__memfunc_setup("GetFileBytesWritten",1940,G__G__IO_111_0_113, 110, -1, G__defined_typename("Long64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long64_t (*)())(&TFile::GetFileBytesWritten) ), 0);
   G__memfunc_setup("GetFileReadCalls",1547,G__G__IO_111_0_114, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TFile::GetFileReadCalls) ), 0);
   G__memfunc_setup("GetReadaheadSize",1578,G__G__IO_111_0_115, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TFile::GetReadaheadSize) ), 0);
   G__memfunc_setup("SetFileBytesRead",1583,G__G__IO_111_0_116, 121, -1, -1, 0, 1, 3, 1, 0, "n - 'Long64_t' 0 '0' bytes", (char*)NULL, (void*) G__func2void( (void (*)(Long64_t))(&TFile::SetFileBytesRead) ), 0);
   G__memfunc_setup("SetFileBytesWritten",1952,G__G__IO_111_0_117, 121, -1, -1, 0, 1, 3, 1, 0, "n - 'Long64_t' 0 '0' bytes", (char*)NULL, (void*) G__func2void( (void (*)(Long64_t))(&TFile::SetFileBytesWritten) ), 0);
   G__memfunc_setup("SetFileReadCalls",1559,G__G__IO_111_0_118, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '0' readcalls", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TFile::SetFileReadCalls) ), 0);
   G__memfunc_setup("SetReadaheadSize",1590,G__G__IO_111_0_119, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '256000' bufsize", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TFile::SetReadaheadSize) ), 0);
   G__memfunc_setup("SetReadStreamerInfo",1911,G__G__IO_111_0_120, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' readinfo", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TFile::SetReadStreamerInfo) ), 0);
   G__memfunc_setup("GetFileCounter",1408,G__G__IO_111_0_121, 110, -1, G__defined_typename("Long64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long64_t (*)())(&TFile::GetFileCounter) ), 0);
   G__memfunc_setup("IncrementFileCounter",2053,G__G__IO_111_0_122, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFile::IncrementFileCounter) ), 0);
   G__memfunc_setup("SetCacheFileDir",1439,G__G__IO_111_0_123, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"C - - 10 - cacheDir g - 'Bool_t' 0 'kTRUE' operateDisconnected "
"g - 'Bool_t' 0 'kFALSE' forceCacheread", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*, Bool_t, Bool_t))(&TFile::SetCacheFileDir) ), 0);
   G__memfunc_setup("GetCacheFileDir",1427,G__G__IO_111_0_124, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFile::GetCacheFileDir) ), 0);
   G__memfunc_setup("ShrinkCacheFileDir",1762,G__G__IO_111_0_125, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 1, 0, 
"n - 'Long64_t' 0 - shrinkSize l - 'Long_t' 0 '0' cleanupInteval", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Long64_t, Long_t))(&TFile::ShrinkCacheFileDir) ), 0);
   G__memfunc_setup("Cp",179,G__G__IO_111_0_126, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"C - - 10 - src C - - 10 - dst "
"g - 'Bool_t' 0 'kTRUE' progressbar h - 'UInt_t' 0 '1000000' buffersize", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*, const char*, Bool_t, UInt_t))(&TFile::Cp) ), 0);
   G__memfunc_setup("SetOpenTimeout",1445,G__G__IO_111_0_127, 104, -1, G__defined_typename("UInt_t"), 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - timeout", "in ms", (void*) G__func2void( (UInt_t (*)(UInt_t))(&TFile::SetOpenTimeout) ), 0);
   G__memfunc_setup("GetOpenTimeout",1433,G__G__IO_111_0_128, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", "in ms", (void*) G__func2void( (UInt_t (*)())(&TFile::GetOpenTimeout) ), 0);
   G__memfunc_setup("SetOnlyStaged",1318,G__G__IO_111_0_129, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - onlystaged", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Bool_t))(&TFile::SetOnlyStaged) ), 0);
   G__memfunc_setup("GetOnlyStaged",1306,G__G__IO_111_0_130, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TFile::GetOnlyStaged) ), 0);
   G__memfunc_setup("Class",502,G__G__IO_111_0_131, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_111_0_132, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_111_0_133, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_111_0_134, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_111_0_138, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_111_0_139, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_111_0_140, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_111_0_141, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_111_0_142, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFile", 594, G__G__IO_111_0_143, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArchiveMember(void) {
   /* TArchiveMember */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TArchiveMember));
   G__memfunc_setup("TArchiveMember",1390,G__G__IO_112_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TArchiveMember), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArchiveMember",1390,G__G__IO_112_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TArchiveMember), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArchiveMember",1390,G__G__IO_112_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TArchiveMember), -1, 0, 1, 1, 1, 0, "u 'TArchiveMember' - 11 - member", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__IO_112_0_4, 117, G__get_linked_tagnum(&G__G__IOLN_TArchiveMember), -1, 1, 1, 1, 1, 0, "u 'TArchiveMember' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetComment",1011,G__G__IO_112_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetModTime",975,G__G__IO_112_0_7, 117, G__get_linked_tagnum(&G__G__IOLN_TDatime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__G__IO_112_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFilePosition",1525,G__G__IO_112_0_9, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompressedSize",1744,G__G__IO_112_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecompressedSize",1945,G__G__IO_112_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDirectory",1137,G__G__IO_112_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__IO_112_0_13, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArchiveMember::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_112_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArchiveMember::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_112_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArchiveMember::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_112_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArchiveMember::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_112_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__IO_112_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArchiveMember::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_112_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArchiveMember::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_112_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArchiveMember::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_112_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArchiveMember::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArchiveMember", 1516, G__G__IO_112_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArchiveFile(void) {
   /* TArchiveFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TArchiveFile));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TArchiveFile), -1, 1, 1, 1, 4, 0, "u 'TArchiveFile' - 11 - -", "Not implemented because TArchiveFile can not be copied.", (void*) NULL, 0);
   G__memfunc_setup("ParseUrl",814,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 2, 0, 
"C - - 10 - url u 'TString' - 1 - archive "
"u 'TString' - 1 - member u 'TString' - 1 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenArchive",1108,G__G__IO_113_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCurrentMember",1639,G__G__IO_113_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetMember",900,G__G__IO_113_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - member", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMember",900,G__G__IO_113_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMemberFilePosition",2125,G__G__IO_113_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMember",888,G__G__IO_113_0_11, 85, G__get_linked_tagnum(&G__G__IOLN_TArchiveMember), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMembers",1003,G__G__IO_113_0_12, 85, G__get_linked_tagnum(&G__G__IOLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfMembers",1801,G__G__IO_113_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArchiveName",1379,G__G__IO_113_0_14, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMemberName",1273,G__G__IO_113_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMemberIndex",1392,G__G__IO_113_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Open",402,G__G__IO_113_0_17, 85, G__get_linked_tagnum(&G__G__IOLN_TArchiveFile), -1, 0, 2, 3, 1, 0, 
"C - - 10 - url U 'TFile' - 0 - file", (char*)NULL, (void*) G__func2void( (TArchiveFile* (*)(const char*, TFile*))(&TArchiveFile::Open) ), 0);
   G__memfunc_setup("Class",502,G__G__IO_113_0_18, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArchiveFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_113_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArchiveFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_113_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArchiveFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_113_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArchiveFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_113_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__IO_113_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArchiveFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_113_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArchiveFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_113_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArchiveFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_113_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArchiveFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArchiveFile", 1300, G__G__IO_113_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerInfo(void) {
   /* TStreamerInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo));
   G__memfunc_setup("GetValueAux",1099,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 4, 0, 
"i - 'Int_t' 0 - type Y - - 0 - ladd "
"i - - 0 - k i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintValueAux",1336,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 3, 4, 0, 
"C - - 0 - ladd i - 'Int_t' 0 - atype "
"U 'TStreamerElement' - 0 - aElement i - 'Int_t' 0 - aleng "
"I - 'Int_t' 0 - count", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateIncludes",1634,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 3, 1, 4, 0, 
"E - - 0 - fp C - - 0 - inclist "
"U 'TList' - 10 - extrainfos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateDeclaration",1937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"E - - 0 - fp E - - 0 - sfp "
"U 'TList' - 10 - subClasses g - 'Bool_t' 0 'kTRUE' top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertArtificialElements",2474,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObjArray' - 10 - rules", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestructorImpl",1473,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"Y - - 0 - p g - 'Bool_t' 0 - dtorOnly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerInfo",1315,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo), -1, 0, 1, 1, 4, 0, "u 'TStreamerInfo' - 11 - -", "TStreamerInfo are copiable.  Not Implemented.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo), -1, 1, 1, 1, 4, 0, "u 'TStreamerInfo' - 11 - -", "TStreamerInfo are copiable.  Not Implemented.", (void*) NULL, 0);
   G__memfunc_setup("TStreamerInfo",1315,G__G__IO_114_0_9, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerInfo",1315,G__G__IO_114_0_10, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfo), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildCheck",974,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildEmulated",1313,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildOld",783,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildFor",791,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallShowMembers",1512,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"Y - - 0 - obj u 'TMemberInspector' - 1 - insp", (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("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CompareContent",1442,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"U 'TClass' - 0 - cl U 'TVirtualStreamerInfo' - 0 - info "
"g - 'Bool_t' 0 - warn g - 'Bool_t' 0 - complete", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compile",713,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeSize",1144,G__G__IO_114_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceWriteInfo",1414,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 - file g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateHeaderFile",1780,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - dirname U 'TList' - 10 '0' subClasses "
"U 'TList' - 10 '0' extrainfos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActualClass",1392,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 1, 1, 1, 8, "Y - - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckSum",1075,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckSum",1075,G__G__IO_114_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassVersion",1532,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDataMemberOffset",1881,G__G__IO_114_0_29, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"U 'TDataMember' - 0 - dm U 'TMemberStreamer' - 1 - streamer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElements",1117,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElems",790,(G__InterfaceMethod) NULL,75, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReadMemberWiseActions",2397,G__G__IO_114_0_32, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - forCollection", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadObjectWiseActions",2396,G__G__IO_114_0_33, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdata",776,G__G__IO_114_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumber",905,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLengths",1013,G__G__IO_114_0_36, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethods",1012,G__G__IO_114_0_37, 75, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewTypes",1119,G__G__IO_114_0_38, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffset",903,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOffsets",1018,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOldVersion",1317,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Version_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOnFileClassVersion",2105,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   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("GetSizeElements",1528,G__G__IO_114_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamerElement",1837,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TStreamerElement), -1, 0, 2, 1, 1, 8, 
"C - - 10 - datamember i - 'Int_t' 1 - offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStreamerElementReal",2225,G__G__IO_114_0_46, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerElement), -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypes",821,G__G__IO_114_0_47, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__IO_114_0_48, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"C - - 0 - pointer i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - j i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueClones",1409,G__G__IO_114_0_49, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"U 'TClonesArray' - 0 - clones i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - j i - 'Int_t' 0 - k "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueSTL",1040,G__G__IO_114_0_50, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"U 'TVirtualCollectionProxy' - 0 - cont i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - j i - 'Int_t' 0 - k "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueSTLP",1120,G__G__IO_114_0_51, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"U 'TVirtualCollectionProxy' - 0 - cont i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - j i - 'Int_t' 0 - k "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   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("NewInfo",694,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualStreamerInfo), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("New",298,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewArray",809,(G__InterfaceMethod) NULL,89, -1, -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - nElements Y - - 0 '0' ary", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destructor",1071,(G__InterfaceMethod) NULL,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__InterfaceMethod) NULL,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("PrintValue",1034,G__G__IO_114_0_58, 121, -1, -1, 0, 5, 1, 1, 8, 
"C - - 10 - name C - - 0 - pointer "
"i - 'Int_t' 0 - i i - 'Int_t' 0 - len "
"i - 'Int_t' 0 '1000' lenmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintValueClones",1646,G__G__IO_114_0_59, 121, -1, -1, 0, 5, 1, 1, 8, 
"C - - 10 - name U 'TClonesArray' - 0 - clones "
"i - 'Int_t' 0 - i i - 'Int_t' 0 - eoffset "
"i - 'Int_t' 0 '1000' lenmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintValueSTL",1277,G__G__IO_114_0_60, 121, -1, -1, 0, 5, 1, 1, 8, 
"C - - 10 - name U 'TVirtualCollectionProxy' - 0 - cont "
"i - 'Int_t' 0 - i i - 'Int_t' 0 - eoffset "
"i - 'Int_t' 0 '1000' lenmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBufferClones",1594,G__G__IO_114_0_61, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - clones "
"i - 'Int_t' 0 - nc i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBufferSTL",1225,G__G__IO_114_0_62, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TVirtualCollectionProxy' - 0 - cont "
"i - 'Int_t' 0 - nc i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCheckSum",1087,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClass",802,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClassVersion",1544,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TagFile",668,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - fFile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBuffer",1125,G__G__IO_114_0_67, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b C - - 0 - pointer "
"i - 'Int_t' 0 - first", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBufferClones",1737,G__G__IO_114_0_68, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - clones "
"i - 'Int_t' 0 - nc i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBufferSTL",1368,G__G__IO_114_0_69, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TVirtualCollectionProxy' - 0 - cont "
"i - 'Int_t' 0 - nc i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBufferSTLPtrs",1793,G__G__IO_114_0_70, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TVirtualCollectionProxy' - 0 - cont "
"i - 'Int_t' 0 - nc i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - eoffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - oldClass U 'TClass' - 0 - newClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenEmulatedProxy",1645,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), -1, 0, 1, 1, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenEmulatedClassStreamer",2436,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClassStreamer), -1, 0, 1, 1, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenExplicitProxy",1662,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenExplicitClassStreamer",2453,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClassStreamer), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentElement",1741,G__G__IO_114_0_76, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerElement), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TStreamerElement* (*)())(&TStreamerInfo::GetCurrentElement) ), 0);
   G__memfunc_setup("Class",502,G__G__IO_114_0_77, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_114_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_114_0_79, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_114_0_80, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_114_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_114_0_85, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_114_0_86, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_114_0_87, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_114_0_88, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerInfo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerInfo", 1441, G__G__IO_114_0_89, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBufferFile(void) {
   /* TBufferFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TBufferFile));
   G__memfunc_setup("TBufferFile",1070,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TBufferFile), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBufferFile",1070,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TBufferFile), -1, 0, 1, 1, 2, 0, "u 'TBufferFile' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBufferFile' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("CheckByteCount",1403,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"h - 'UInt_t' 0 - startpos h - 'UInt_t' 0 - bcnt "
"U 'TClass' - 10 - clss C - - 10 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckCount",999,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckObject",1077,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 3, 1, 2, 0, 
"h - 'UInt_t' 0 - offset U 'TClass' - 10 - cl "
"g - 'Bool_t' 0 'kFALSE' readClass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteObjectClass",1624,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"Y - - 10 - actualObjStart U 'TClass' - 10 - actualClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TBufferFile",1070,G__G__IO_116_0_8, 105, G__get_linked_tagnum(&G__G__IOLN_TBufferFile), -1, 0, 1, 1, 1, 0, "i 'TBuffer::EMode' - 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBufferFile",1070,G__G__IO_116_0_9, 105, G__get_linked_tagnum(&G__G__IOLN_TBufferFile), -1, 0, 2, 1, 1, 0, 
"i 'TBuffer::EMode' - 0 - mode i - 'Int_t' 0 - bufsiz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBufferFile",1070,G__G__IO_116_0_10, 105, G__get_linked_tagnum(&G__G__IOLN_TBufferFile), -1, 0, 5, 1, 1, 0, 
"i 'TBuffer::EMode' - 0 - mode i - 'Int_t' 0 - bufsiz "
"Y - - 0 - buf g - 'Bool_t' 0 'kTRUE' adopt "
"Y - 'ReAllocCharFun_t' 0 '0' reallocfunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapCount",1095,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMappedObject",1486,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 0 - tag Y - - 1 - ptr "
"U 'TClass' - 1 - ClassPtr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapObject",885,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj h - 'UInt_t' 0 '1' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapObject",885,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - cl "
"h - 'UInt_t' 0 '1' offset", (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("InitMap",690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetMap",801,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetReadParam",1177,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mapsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWriteParam",1320,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mapsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckObject",1077,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckObject",1077,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - ptrClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVersionOwner",1553,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckByteCount",1403,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - startpos h - 'UInt_t' 0 - bcnt "
"U 'TClass' - 10 - clss", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckByteCount",1403,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - startpos h - 'UInt_t' 0 - bcnt "
"C - - 10 - classname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetByteCount",1225,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - cntpos g - 'Bool_t' 0 'kFALSE' packInVersion", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SkipVersion",1149,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 '0' cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadVersion",1122,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Version_t"), 0, 3, 1, 1, 0, 
"H - 'UInt_t' 0 '0' start H - 'UInt_t' 0 '0' bcnt "
"U 'TClass' - 10 '0' cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVersion",1265,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl g - 'Bool_t' 0 'kFALSE' useBcnt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVersionMemberWise",2273,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl g - 'Bool_t' 0 'kFALSE' useBcnt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadObjectAny",1275,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cast", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SkipObjectAny",1302,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TagStreamerInfo",1515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IncrementLevel",1437,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStreamerElementNumber",2466,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DecrementLevel",1423,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInfo",684,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualStreamerInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassBegin",987,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - - s - 'Version_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassEnd",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassMember",1102,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - - C - - 10 '0' - "
"i - 'Int_t' 0 '-1' - i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuf",665,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"Y - - 0 - buf i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBuf",808,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 10 - buf i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadString",1011,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"C - - 0 - s i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteString",1154,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadClass",882,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 '0' cl H - 'UInt_t' 0 '0' objTag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteClass",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadObject",979,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteObject",1122,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteObjectAny",1418,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - ptrClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPidOffset",1188,(G__InterfaceMethod) NULL,114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPidOffset",1200,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBufferDisplacement",2131,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBufferDisplacement",2143,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBufferDisplacement",2143,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - skipped", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFloat16",985,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFloat16",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadDouble32",1084,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteDouble32",1227,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWithFactor",1399,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 0 - ptr d - 'Double_t' 0 - factor "
"d - 'Double_t' 0 - minvalue", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWithNbits",1304,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - ptr i - 'Int_t' 0 - nbits", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWithFactor",1399,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - ptr d - 'Double_t' 0 - factor "
"d - 'Double_t' 0 - minvalue", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWithNbits",1304,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - ptr i - 'Int_t' 0 - nbits", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "G - 'Bool_t' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Char_t' 1 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "B - 'UChar_t' 1 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "S - 'Short_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "R - 'UShort_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "I - 'Int_t' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "H - 'UInt_t' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "L - 'Long_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "K - 'ULong_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "N - 'Long64_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "M - 'ULong64_t' 1 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "F - 'Float_t' 1 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArray",891,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 1 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArrayFloat16",1496,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"F - 'Float_t' 1 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadArrayDouble32",1595,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 1 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "G - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "B - 'UChar_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "S - 'Short_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "R - 'UShort_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "I - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "L - 'Long_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "K - 'ULong_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "N - 'Long64_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "M - 'ULong64_t' 0 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "F - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArray",1507,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArrayFloat16",2112,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStaticArrayDouble32",2211,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 0 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 0 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArrayString",1920,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 0 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 0 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 0 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 0 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 0 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 0 - ll i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArrayFloat16",1894,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 0 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArrayDouble32",1993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"Y - - 0 - start U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n U 'TMemberStreamer' - 0 '0' s "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"Y - - 2 - startp U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n g - 'Bool_t' 0 'kFALSE' isPreAlloc "
"U 'TMemberStreamer' - 0 '0' s U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 10 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 10 - ll i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArray",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArrayFloat16",1639,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteArrayDouble32",1738,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 10 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArrayString",2063,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 10 - ll i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArrayFloat16",2037,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArrayDouble32",2136,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"Y - - 0 - start U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n U 'TMemberStreamer' - 0 '0' s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 2 - startp U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n g - 'Bool_t' 0 'kFALSE' isPreAlloc "
"U 'TMemberStreamer' - 0 '0' s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamObject",1219,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - obj u 'type_info' - 11 - typeinfo "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamObject",1219,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - obj C - - 10 - className "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamObject",1219,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - obj U 'TClass' - 10 - cl "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamObject",1219,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBool",776,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadChar",762,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 1 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadUChar",847,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 1 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadShort",908,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadUShort",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadInt",679,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadUInt",764,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadLong",780,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadULong",865,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 1 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadLong64",886,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 1 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadULong64",971,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 1 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFloat",882,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 1 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadDouble",983,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 1 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadCharP",842,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTString",1095,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBool",919,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteChar",905,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteUChar",990,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteShort",1051,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteUShort",1136,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteInt",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteUInt",907,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteLong",923,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteULong",1008,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteLong64",1029,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteULong64",1114,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 0 - ll", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFloat",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteDouble",1126,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteCharP",985,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTString",1238,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLastProcessID",1568,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TProcessID), -1, 0, 1, 1, 1, 8, "U 'TRefTable' - 0 - reftable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTRefExecId",1219,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadProcessID",1256,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TProcessID), -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - pidf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteProcessID",1399,(G__InterfaceMethod) NULL,114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 0, "U 'TProcessID' - 0 - pid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForceWriteInfo",1414,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForceWriteInfoClones",2026,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClonesArray' - 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadClones",992,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TClonesArray' - 0 - a i - 'Int_t' 0 - nobjects "
"s - 'Version_t' 0 - objvers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteClones",1135,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - a i - 'Int_t' 0 - nobjects", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadClassEmulated",1699,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - object "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadClassBuffer",1484,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - pointer "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadClassBuffer",1484,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - pointer "
"i - 'Int_t' 0 - version h - 'UInt_t' 0 - start "
"h - 'UInt_t' 0 - count U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteClassBuffer",1627,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - pointer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadSequence",1205,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TStreamerInfoActions::TActionSequence' - 11 - sequence Y - - 0 - object", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadSequenceVecPtr",1801,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TStreamerInfoActions::TActionSequence' - 11 - sequence Y - - 0 - start_collection "
"Y - - 0 - end_collection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadSequence",1205,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TStreamerInfoActions::TActionSequence' - 11 - sequence Y - - 0 - start_collection "
"Y - - 0 - end_collection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalReadParam",1770,G__G__IO_116_0_192, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 - mapsize", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TBufferFile::SetGlobalReadParam) ), 0);
   G__memfunc_setup("SetGlobalWriteParam",1913,G__G__IO_116_0_193, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 - mapsize", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TBufferFile::SetGlobalWriteParam) ), 0);
   G__memfunc_setup("GetGlobalReadParam",1758,G__G__IO_116_0_194, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TBufferFile::GetGlobalReadParam) ), 0);
   G__memfunc_setup("GetGlobalWriteParam",1901,G__G__IO_116_0_195, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TBufferFile::GetGlobalWriteParam) ), 0);
   G__memfunc_setup("Class",502,G__G__IO_116_0_196, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBufferFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_116_0_197, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBufferFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_116_0_198, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBufferFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_116_0_199, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBufferFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_116_0_203, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_116_0_204, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBufferFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_116_0_205, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBufferFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_116_0_206, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBufferFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_116_0_207, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBufferFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBufferFile", 1196, G__G__IO_116_0_208, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollectionProxyFactory(void) {
   /* TCollectionProxyFactory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory));
   G__memfunc_setup("GenEmulatedProxy",1645,G__G__IO_172_0_1, 85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), -1, 0, 1, 3, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) G__func2void( (TVirtualCollectionProxy* (*)(const char*))(&TCollectionProxyFactory::GenEmulatedProxy) ), 0);
   G__memfunc_setup("GenEmulatedClassStreamer",2436,G__G__IO_172_0_2, 85, G__get_linked_tagnum(&G__G__IOLN_TClassStreamer), -1, 0, 1, 3, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) G__func2void( (TClassStreamer* (*)(const char*))(&TCollectionProxyFactory::GenEmulatedClassStreamer) ), 0);
   G__memfunc_setup("GenEmulatedMemberStreamer",2534,G__G__IO_172_0_3, 85, G__get_linked_tagnum(&G__G__IOLN_TMemberStreamer), -1, 0, 1, 3, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) G__func2void( (TMemberStreamer* (*)(const char*))(&TCollectionProxyFactory::GenEmulatedMemberStreamer) ), 0);
   G__memfunc_setup("GenExplicitProxy",1662,G__G__IO_172_0_4, 85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), G__defined_typename("TCollectionProxyFactory::Proxy_t"), 0, 2, 3, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (TCollectionProxyFactory::Proxy_t* (*)(const ROOT::TCollectionProxyInfo&, TClass*))(&TCollectionProxyFactory::GenExplicitProxy) ), 0);
   G__memfunc_setup("GenExplicitStreamer",1951,G__G__IO_172_0_5, 85, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionStreamer), -1, 0, 2, 3, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (TGenCollectionStreamer* (*)(const ROOT::TCollectionProxyInfo&, TClass*))(&TCollectionProxyFactory::GenExplicitStreamer) ), 0);
   G__memfunc_setup("GenExplicitClassStreamer",2453,G__G__IO_172_0_6, 85, G__get_linked_tagnum(&G__G__IOLN_TClassStreamer), -1, 0, 2, 3, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (TClassStreamer* (*)(const ROOT::TCollectionProxyInfo&, TClass*))(&TCollectionProxyFactory::GenExplicitClassStreamer) ), 0);
   G__memfunc_setup("GenExplicitMemberStreamer",2551,G__G__IO_172_0_7, 85, G__get_linked_tagnum(&G__G__IOLN_TMemberStreamer), -1, 0, 2, 3, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (TMemberStreamer* (*)(const ROOT::TCollectionProxyInfo&, TClass*))(&TCollectionProxyFactory::GenExplicitMemberStreamer) ), 0);
   // automatic default constructor
   G__memfunc_setup("TCollectionProxyFactory", 2394, G__G__IO_172_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TCollectionProxyFactory", 2394, G__G__IO_172_0_9, (int) ('i'), 
G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory), -1, 0, 1, 1, 1, 0, "u 'TCollectionProxyFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCollectionProxyFactory", 2520, G__G__IO_172_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_172_0_11, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TCollectionProxyFactory), -1, 1, 1, 1, 1, 0, "u 'TCollectionProxyFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGenCollectionProxy(void) {
   /* TGenCollectionProxy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy));
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitializeEx",1231,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteItem",994,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"g - 'Bool_t' 0 - force Y - - 0 - ptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckFunctions",1431,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenCollectionProxy",1948,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 0, 1, 4, 0, "", "not implemented on purpose.", (void*) NULL, 0);
   G__memfunc_setup("Generate",811,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGenCollectionProxy",1948,G__G__IO_173_0_7, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 1, 1, 1, 0, "u 'TGenCollectionProxy' - 11 - copy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenCollectionProxy",1948,G__G__IO_173_0_8, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 2, 1, 1, 0, 
"u 'type_info' 'TGenCollectionProxy::Info_t' 10 - typ h - 'size_t' 0 - iter_size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenCollectionProxy",1948,G__G__IO_173_0_9, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollectionClass",1826,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCollectionType",1742,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIncrement",1221,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PushProxy",962,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - objstart", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopProxy",849,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasPointers",1136,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValueClass",1299,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValueClass",1311,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - newcl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__IOLN_EDataType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,G__G__IO_173_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - n g - 'Bool_t' 0 - force_delete", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL,89, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - n g - 'Bool_t' 0 - forceDelete", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Commit",617,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - env", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__IO_173_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - refBuffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__IO_173_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - refBuffer Y - - 0 - pObject "
"i - - 0 - siz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__IO_173_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - refBuffer Y - - 0 - pObject", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_173_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_173_0_30, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - obj "
"U 'TClass' - 10 - onfileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOnFileClass",1375,G__G__IO_173_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOnFileClass",1363,G__G__IO_173_0_32, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetConversionReadMemberWiseActions",3459,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 0 - oldClass i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReadMemberWiseActions",2397,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWriteMemberWiseActions",2540,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunctionCreateIterators",2679,(G__InterfaceMethod) NULL,89, -1, G__defined_typename("TVirtualCollectionProxy::CreateIterators_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunctionCopyIterator",2379,(G__InterfaceMethod) NULL,89, -1, G__defined_typename("TVirtualCollectionProxy::CopyIterator_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunctionNext",1541,(G__InterfaceMethod) NULL,89, -1, G__defined_typename("TVirtualCollectionProxy::Next_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunctionDeleteIterator",2563,(G__InterfaceMethod) NULL,89, -1, G__defined_typename("TVirtualCollectionProxy::DeleteIterator_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunctionDeleteTwoIterators",2992,(G__InterfaceMethod) NULL,89, -1, G__defined_typename("TVirtualCollectionProxy::DeleteTwoIterators_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~TGenCollectionProxy", 2074, G__G__IO_173_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGenCollectionProxycLcLValue(void) {
   /* TGenCollectionProxy::Value */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue));
   G__memfunc_setup("Value",509,G__G__IO_175_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue), -1, 0, 1, 1, 1, 0, "u 'TGenCollectionProxy::Value' - 11 - inside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__IO_175_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteItem",994,G__G__IO_175_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__IO_175_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Value", 635, G__G__IO_175_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_175_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLValue), -1, 1, 1, 1, 1, 0, "u 'TGenCollectionProxy::Value' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGenCollectionProxycLcLMethod(void) {
   /* TGenCollectionProxy::Method */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod));
   G__memfunc_setup("Method",609,G__G__IO_177_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Method",609,G__G__IO_177_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod), -1, 0, 1, 1, 1, 0, "Y - 'TGenCollectionProxy::Method::Call_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Method",609,G__G__IO_177_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod), -1, 0, 1, 1, 1, 0, "u 'TGenCollectionProxy::Method' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("invoke",652,G__G__IO_177_0_4, 89, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - obj", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Method", 735, G__G__IO_177_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_177_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxycLcLMethod), -1, 1, 1, 1, 1, 0, "u 'TGenCollectionProxy::Method' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEmulatedCollectionProxy(void) {
   /* TEmulatedCollectionProxy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy));
   G__memfunc_setup("InitializeEx",1231,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadItems",894,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - - 0 - nElements u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteItems",1037,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - - 0 - nElements u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shrink",623,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"h - 'UInt_t' 0 - nCurr h - 'UInt_t' 0 - left "
"g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Expand",608,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"h - 'UInt_t' 0 - nCurr h - 'UInt_t' 0 - left", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Generate",811,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEmulatedCollectionProxy",2483,G__G__IO_190_0_7, 105, G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy), -1, 0, 1, 1, 1, 0, "u 'TEmulatedCollectionProxy' - 11 - copy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEmulatedCollectionProxy",2483,G__G__IO_190_0_8, 105, G__get_linked_tagnum(&G__G__IOLN_TEmulatedCollectionProxy), -1, 0, 1, 1, 1, 0, "C - - 10 - cl_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("New",298,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("New",298,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - memory", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewArray",809,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - nElements", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewArray",809,(G__InterfaceMethod) NULL,89, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - nElements Y - - 0 - memory", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destructor",1071,(G__InterfaceMethod) NULL,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__InterfaceMethod) NULL,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__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - n g - 'Bool_t' 0 - force_delete", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL,89, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - n g - 'Bool_t' 0 - forceDelete", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Commit",617,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - env", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - pObj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - pObj "
"U 'TClass' - 10 - onfile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - refBuffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - pObj "
"i - - 0 - siz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,G__G__IO_190_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEmulatedCollectionProxy", 2609, G__G__IO_190_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollectionStreamer(void) {
   /* TCollectionStreamer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer), -1, 1, 1, 1, 4, 0, "u 'TCollectionStreamer' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("InvalidProxyError",1779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCollectionStreamer",1955,G__G__IO_191_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCollectionStreamer",1955,G__G__IO_191_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TCollectionStreamer), -1, 0, 1, 1, 1, 0, "u 'TCollectionStreamer' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdoptStreamer",1339,G__G__IO_191_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGenCollectionProxy' - 0 - streamer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__IO_191_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TBuffer' - 1 - refBuffer Y - - 0 - obj "
"i - - 0 - siz U 'TClass' - 0 - onFileClass", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCollectionStreamer", 2081, G__G__IO_191_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollectionClassStreamer(void) {
   /* TCollectionClassStreamer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer));
   G__memfunc_setup("TCollectionClassStreamer",2457,G__G__IO_192_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCollectionClassStreamer",2457,G__G__IO_192_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TCollectionClassStreamer), -1, 0, 1, 1, 1, 0, "u 'TCollectionClassStreamer' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stream",620,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - obj "
"U 'TClass' - 10 - onfileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Generate",811,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TClassStreamer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,G__G__IO_192_0_6, 85, G__get_linked_tagnum(&G__G__IOLN_TGenCollectionProxy), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCollectionClassStreamer", 2583, G__G__IO_192_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollectionMemberStreamer(void) {
   /* TCollectionMemberStreamer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer));
   G__memfunc_setup("TCollectionMemberStreamer",2555,G__G__IO_193_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCollectionMemberStreamer",2555,G__G__IO_193_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TCollectionMemberStreamer), -1, 0, 1, 1, 1, 0, "u 'TCollectionMemberStreamer' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - obj "
"i - 'Int_t' 0 '0' siz", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~TCollectionMemberStreamer", 2681, G__G__IO_193_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTKey(void) {
   /* TKey */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TKey));
   G__memfunc_setup("TKey",381,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 1, 1, 4, 0, "u 'TKey' - 11 - -", "TKey objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 1, 1, 1, 4, 0, "u 'TKey' - 11 - -", "TKey objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("Read",380,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - nbytes U 'TFile' - 0 '0' f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TDirectory' - 0 - motherDir C - - 10 - classname "
"n - 'Long64_t' 0 - filepos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Currently only for the use of TBasket.", (void*) NULL, 1);
   G__memfunc_setup("WriteFileKeepBuffer",1898,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TFile' - 0 '0' f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_8, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_9, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_10, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TClass' - 10 - cl i - 'Int_t' 0 - nbytes "
"U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_11, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - name u 'TString' - 11 - title "
"U 'TClass' - 10 - cl i - 'Int_t' 0 - nbytes "
"U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_12, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 4, 1, 1, 0, 
"U 'TObject' - 10 - obj C - - 10 - name "
"i - 'Int_t' 0 - bufsize U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_13, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 5, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - cl "
"C - - 10 - name i - 'Int_t' 0 - bufsize "
"U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKey",381,G__G__IO_202_0_14, 105, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 3, 1, 1, 0, 
"n - 'Long64_t' 0 - pointer i - 'Int_t' 0 - nbytes "
"U 'TDirectory' - 0 '0' motherDir", (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("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("DeleteBuffer",1197,G__G__IO_202_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClassName",1175,G__G__IO_202_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIconName",1066,(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("GetBuffer",890,G__G__IO_202_0_22, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBufferRef",1175,G__G__IO_202_0_23, 85, G__get_linked_tagnum(&G__G__IOLN_TBuffer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCycle",784,G__G__IO_202_0_24, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDatime",884,G__G__IO_202_0_25, 117, G__get_linked_tagnum(&G__G__IOLN_TDatime), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFile",672,G__G__IO_202_0_26, 85, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeep",677,G__G__IO_202_0_27, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeylen",904,G__G__IO_202_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherDir",1198,G__G__IO_202_0_29, 85, G__get_linked_tagnum(&G__G__IOLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbytes",917,G__G__IO_202_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjlen",890,G__G__IO_202_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersion",1030,G__G__IO_202_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeekKey",977,G__G__IO_202_0_33, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekPdir",1079,G__G__IO_202_0_34, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (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("IncrementPidOffset",1833,G__G__IO_202_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - offset", (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("Keep",389,G__G__IO_202_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (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("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("Read",380,G__G__IO_202_0_41, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadObj",663,G__G__IO_202_0_42, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadObjWithBuffer",1677,G__G__IO_202_0_43, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 0 - bufferRead", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadObjectAny",1275,G__G__IO_202_0_44, 89, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - expectedClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_202_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadKeyBuffer",1279,G__G__IO_202_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadFile",764,G__G__IO_202_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBuffer",902,G__G__IO_202_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__IO_202_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 10 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMotherDir",1210,G__G__IO_202_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFile",907,G__G__IO_202_0_52, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1' cycle U 'TFile' - 0 '0' f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__IO_202_0_53, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TKey::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_202_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKey::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_202_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TKey::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_202_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TKey::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_202_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__IO_202_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKey::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_202_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TKey::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_202_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKey::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_202_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TKey::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TKey", 507, G__G__IO_202_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDirectoryFile(void) {
   /* TDirectoryFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile));
   G__memfunc_setup("CleanTargets",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDirectoryFile",1417,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile), -1, 0, 1, 1, 4, 0, "u 'TDirectoryFile' - 11 - directory", "Directories cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TDirectoryFile' - 11 - -", "Directories cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("TDirectoryFile",1417,G__G__IO_204_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDirectoryFile",1417,G__G__IO_204_0_5, 105, G__get_linked_tagnum(&G__G__IOLN_TDirectoryFile), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - 'Option_t' 10 '\"\"' option U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' replace", (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 g - 'Bool_t' 0 'kFALSE' replace", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AppendKey",897,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TKey' - 0 - key", (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("Build",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 '0' motherFile U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneObject",1096,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj g - 'Bool_t' 0 'kTRUE' autoadd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '0' path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' namecycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindKey",682,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 1, 1, 1, 8, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindKeyAny",978,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 1, 1, 1, 8, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObjectAny",1280,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObjectAnyFile",1664,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Get",288,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - namecycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirectory",1237,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TDirectory), -1, 0, 3, 1, 1, 0, 
"C - - 10 - apath g - 'Bool_t' 0 'false' printError "
"C - - 10 '\"GetDirectory\"' funcname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectChecked",1566,(G__InterfaceMethod) NULL,89, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - namecycle C - - 10 - classname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectChecked",1566,(G__InterfaceMethod) NULL,89, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - namecycle U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectUnchecked",1793,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - namecycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBufferSize",1301,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCreationDate",1491,G__G__IO_204_0_27, 117, G__get_linked_tagnum(&G__G__IOLN_TDatime), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFile",672,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKey",585,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TKey), -1, 0, 2, 1, 1, 8, 
"C - - 10 - name s - 'Short_t' 0 '9999' cycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfKeys",1293,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetModificationDate",1908,G__G__IO_204_0_31, 117, G__get_linked_tagnum(&G__G__IOLN_TDatime), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbytesKeys",1329,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNkeys",810,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekDir",967,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekParent",1298,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekKeys",1092,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsModified",989,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsWritable",1014,(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("mkdir",535,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TDirectory), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenFile",786,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TFile), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress "
"i - 'Int_t' 0 '0' netopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Purge",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 '1' nkeep", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadAll",661,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadKeys",792,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' forceRead", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTObject",1063,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 - keyname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("rmdir",542,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Save",399,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveSelf",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveObjectAs",1178,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"U 'TObject' - 10 - obj C - - 10 '\"\"' filename "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBufferSize",1313,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModified",1101,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSeekDir",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTRefAction",1275,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - ref U 'TObject' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWritable",1126,G__G__IO_204_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' writable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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' opt "
"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' opt "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTObject",1206,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TObject' - 10 - obj C - - 10 '0' name "
"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteObjectAny",1418,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 10 - obj C - - 10 - classname "
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteObjectAny",1418,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - cl "
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteDirHeader",1395,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteKeys",935,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__IO_204_0_63, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDirectoryFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_204_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDirectoryFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_204_0_65, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDirectoryFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_204_0_66, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDirectoryFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_204_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_204_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDirectoryFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_204_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDirectoryFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_204_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDirectoryFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_204_0_74, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDirectoryFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDirectoryFile", 1543, G__G__IO_204_0_75, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEmulatedMapProxy(void) {
   /* TEmulatedMapProxy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy));
   G__memfunc_setup("ReadMap",666,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - - 0 - nElements u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMap",809,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - - 0 - nElements u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Generate",811,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_TVirtualCollectionProxy), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEmulatedMapProxy",1733,G__G__IO_211_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy), -1, 0, 1, 1, 1, 0, "u 'TEmulatedMapProxy' - 11 - copy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEmulatedMapProxy",1733,G__G__IO_211_0_5, 105, G__get_linked_tagnum(&G__G__IOLN_TEmulatedMapProxy), -1, 0, 1, 1, 1, 0, "C - - 10 - cl_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - pObj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - pObj "
"U 'TClass' - 10 - onfile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - refBuffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - buff Y - - 0 - pObj "
"i - - 0 - siz", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~TEmulatedMapProxy", 1859, G__G__IO_211_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFileCacheRead(void) {
   /* TFileCacheRead */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead));
   G__memfunc_setup("TFileCacheRead",1316,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead), -1, 0, 1, 1, 4, 0, "u 'TFileCacheRead' - 11 - -", "cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead), -1, 1, 1, 1, 4, 0, "u 'TFileCacheRead' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileCacheRead",1316,G__G__IO_213_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileCacheRead",1316,G__G__IO_213_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TFileCacheRead), -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 - file i - 'Int_t' 0 - buffersize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBranch",855,G__G__IO_213_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TBranch' - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBranch",855,G__G__IO_213_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBufferSize",1301,G__G__IO_213_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUnzipBuffer",1424,G__G__IO_213_0_8, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 2 - - n - 'Long64_t' 0 - - "
"i - 'Int_t' 0 - - G - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAsyncReading",1396,G__G__IO_213_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLearning",1004,G__G__IO_213_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Prefetch",817,G__G__IO_213_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - pos i - 'Int_t' 0 - len", (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("ReadBufferExt",1287,G__G__IO_213_0_13, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len i - 'Int_t' 1 - loc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_213_0_14, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFile",684,G__G__IO_213_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSkipZip",1014,G__G__IO_213_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", "This function is only used by TTreeCacheUnzip (ignore it)", (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__IO_213_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__IO_213_0_18, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileCacheRead::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_213_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileCacheRead::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_213_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileCacheRead::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_213_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileCacheRead::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_213_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__IO_213_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileCacheRead::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_213_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileCacheRead::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_213_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileCacheRead::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_213_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileCacheRead::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFileCacheRead", 1442, G__G__IO_213_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFileCacheWrite(void) {
   /* TFileCacheWrite */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite));
   G__memfunc_setup("TFileCacheWrite",1459,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite), -1, 0, 1, 1, 4, 0, "u 'TFileCacheWrite' - 11 - -", "cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite), -1, 1, 1, 1, 4, 0, "u 'TFileCacheWrite' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileCacheWrite",1459,G__G__IO_214_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileCacheWrite",1459,G__G__IO_214_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TFileCacheWrite), -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 - file i - 'Int_t' 0 - buffersize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Flush",514,G__G__IO_214_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBytesInCache",1458,G__G__IO_214_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("ReadBuffer",982,G__G__IO_214_0_8, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBuffer",1125,G__G__IO_214_0_9, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFile",684,G__G__IO_214_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__IO_214_0_11, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileCacheWrite::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_214_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileCacheWrite::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_214_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileCacheWrite::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_214_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileCacheWrite::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_214_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__IO_214_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileCacheWrite::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_214_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileCacheWrite::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_214_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileCacheWrite::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_214_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileCacheWrite::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFileCacheWrite", 1585, G__G__IO_214_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFree(void) {
   /* TFree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TFree));
   G__memfunc_setup("TFree",470,G__G__IO_223_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TFree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFree",470,G__G__IO_223_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TFree), -1, 0, 3, 1, 1, 0, 
"U 'TList' - 0 - lfree n - 'Long64_t' 0 - first "
"n - 'Long64_t' 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFree",651,G__G__IO_223_0_3, 85, G__get_linked_tagnum(&G__G__IOLN_TFree), -1, 0, 3, 1, 1, 0, 
"U 'TList' - 0 - lfree n - 'Long64_t' 0 - first "
"n - 'Long64_t' 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBuffer",993,G__G__IO_223_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBestFree",1072,G__G__IO_223_0_5, 85, G__get_linked_tagnum(&G__G__IOLN_TFree), -1, 0, 2, 1, 1, 0, 
"U 'TList' - 0 - lfree i - 'Int_t' 0 - nbytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirst",808,G__G__IO_223_0_6, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLast",692,G__G__IO_223_0_7, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__IO_223_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFirst",820,G__G__IO_223_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - first", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLast",704,G__G__IO_223_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof",624,G__G__IO_223_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__IO_223_0_13, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_223_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_223_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_223_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_223_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__IO_223_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_223_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_223_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_223_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFree::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFree", 470, G__G__IO_223_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__IOLN_TFree), -1, 0, 1, 1, 1, 0, "u 'TFree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFree", 596, G__G__IO_223_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_223_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TFree), -1, 1, 1, 1, 1, 0, "u 'TFree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMapFile(void) {
   /* TMapFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TMapFile));
   G__memfunc_setup("TMapFile",754,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TMapFile), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMapFile",754,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TMapFile), -1, 0, 5, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"C - 'Option_t' 10 - option i - 'Int_t' 0 - size "
"U 'TMapFile' - 1 - newMapFile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMapFile",754,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TMapFile), -1, 0, 2, 1, 2, 0, 
"u 'TMapFile' - 11 - f l - 'Long_t' 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMapFile' - 11 - rhs", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("FindShadowMapFile",1669,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TMapFile), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitDirectory",1353,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 2, 1, 2, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - lock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 2, 1, 2, 0, 
"C - - 10 - name g - 'Bool_t' 0 - lock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SumBuffer",911,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestBuffer",1288,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateSemaphore",1528,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 '0' pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcquireSemaphore",1646,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseSemaphore",1637,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteSemaphore",1527,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MapToAddress",1191,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator delete",1535,G__G__IO_234_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - vp", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TMapFile::operator delete) ), 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("Close",502,G__G__IO_234_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseAddr",1046,G__G__IO_234_0_19, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBreakval",1096,G__G__IO_234_0_20, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectory",1237,G__G__IO_234_0_21, 85, G__get_linked_tagnum(&G__G__IOLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFd",458,G__G__IO_234_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMmallocDesc",1380,G__G__IO_234_0_23, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__IO_234_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,G__G__IO_234_0_26, 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("GetFirst",808,G__G__IO_234_0_28, 85, G__get_linked_tagnum(&G__G__IOLN_TMapRec), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLast",692,G__G__IO_234_0_29, 85, G__get_linked_tagnum(&G__G__IOLN_TMapRec), -1, 0, 0, 1, 1, 8, "", (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("IsWritable",1014,G__G__IO_234_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OrgAddress",1006,G__G__IO_234_0_32, 89, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - addr", (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("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("cd",199,G__G__IO_234_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '0' path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__IO_234_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__IO_234_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__IO_234_0_38, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__IO_234_0_39, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveAll",903,G__G__IO_234_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__IO_234_0_41, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TObject' - 0 '0' retObj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Create",596,G__G__IO_234_0_42, 85, G__get_linked_tagnum(&G__G__IOLN_TMapFile), -1, 0, 4, 3, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"READ\"' option "
"i - 'Int_t' 0 'kDefaultMapSize' size C - - 10 '\"\"' title", (char*)NULL, (void*) G__func2void( (TMapFile* (*)(const char*, Option_t*, Int_t, const char*))(&TMapFile::Create) ), 0);
   G__memfunc_setup("WhichMapFile",1169,G__G__IO_234_0_43, 85, G__get_linked_tagnum(&G__G__IOLN_TMapFile), -1, 0, 1, 3, 1, 0, "Y - - 0 - addr", (char*)NULL, (void*) G__func2void( (TMapFile* (*)(void*))(&TMapFile::WhichMapFile) ), 0);
   G__memfunc_setup("SetMapAddress",1296,G__G__IO_234_0_44, 121, -1, -1, 0, 1, 3, 1, 0, "l - 'Long_t' 0 - addr", (char*)NULL, (void*) G__func2void( (void (*)(Long_t))(&TMapFile::SetMapAddress) ), 0);
   G__memfunc_setup("Class",502,G__G__IO_234_0_45, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMapFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_234_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMapFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_234_0_47, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMapFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_234_0_48, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMapFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_234_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_234_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMapFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_234_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMapFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_234_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMapFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_234_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMapFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMapFile", 880, G__G__IO_234_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTKeyMapFile(void) {
   /* TKeyMapFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile));
   G__memfunc_setup("TKeyMapFile",1051,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile), -1, 0, 1, 1, 4, 0, "u 'TKeyMapFile' - 11 - -", "TKeyMapFile objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile), -1, 1, 1, 1, 4, 0, "u 'TKeyMapFile' - 11 - -", "TKeyMapFile objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("TKeyMapFile",1051,G__G__IO_235_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKeyMapFile",1051,G__G__IO_235_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TKeyMapFile), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - classname "
"U 'TMapFile' - 0 - mapfile", (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("Class",502,G__G__IO_235_0_6, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TKeyMapFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_235_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKeyMapFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_235_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TKeyMapFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_235_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TKeyMapFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_235_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_235_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKeyMapFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_235_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TKeyMapFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_235_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKeyMapFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_235_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TKeyMapFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TKeyMapFile", 1177, G__G__IO_235_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLockFile(void) {
   /* TLockFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TLockFile));
   G__memfunc_setup("TLockFile",861,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TLockFile), -1, 0, 1, 1, 4, 0, "u 'TLockFile' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TLockFile), -1, 1, 1, 1, 4, 0, "u 'TLockFile' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("Lock",393,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"C - - 10 - path i - 'Int_t' 0 - timeLimit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLockFile",861,G__G__IO_236_0_4, 105, G__get_linked_tagnum(&G__G__IOLN_TLockFile), -1, 0, 2, 1, 1, 0, 
"C - - 10 - path i - 'Int_t' 0 '0' timeLimit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__IO_236_0_5, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLockFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_236_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLockFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_236_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLockFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_236_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLockFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_236_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__IO_236_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLockFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_236_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLockFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_236_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLockFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_236_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLockFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLockFile", 987, G__G__IO_236_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMapRec(void) {
   /* TMapRec */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TMapRec));
   G__memfunc_setup("TMapRec",652,G__G__IO_252_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TMapRec), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'TObject' - 10 - obj "
"i - 'Int_t' 0 - size Y - - 0 - buf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__IO_252_0_2, 67, -1, -1, 0, 1, 1, 1, 9, "l - 'Long_t' 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassName",1175,G__G__IO_252_0_3, 67, -1, -1, 0, 1, 1, 1, 9, "l - 'Long_t' 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuffer",890,G__G__IO_252_0_4, 89, -1, -1, 0, 1, 1, 1, 8, "l - 'Long_t' 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufSize",984,G__G__IO_252_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__IO_252_0_6, 85, G__get_linked_tagnum(&G__G__IOLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNext",703,G__G__IO_252_0_7, 85, G__get_linked_tagnum(&G__G__IOLN_TMapRec), -1, 0, 1, 1, 1, 8, "l - 'Long_t' 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TMapRec", 652, G__G__IO_252_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__IOLN_TMapRec), -1, 0, 1, 1, 1, 0, "u 'TMapRec' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMapRec", 778, G__G__IO_252_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_252_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TMapRec), -1, 1, 1, 1, 1, 0, "u 'TMapRec' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerInfoActionscLcLTConfiguration(void) {
   /* TStreamerInfoActions::TConfiguration */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration));
   G__memfunc_setup("TConfiguration",1452,G__G__IO_261_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration), -1, 0, 3, 1, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info h - 'UInt_t' 0 - id "
"i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TConfiguration",1452,G__G__IO_261_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration), -1, 0, 4, 1, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info h - 'UInt_t' 0 - id "
"i - 'Int_t' 0 - offset h - 'UInt_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToOffset",1075,G__G__IO_261_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - delta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,G__G__IO_261_0_4, 85, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__IO_261_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintDebug",1012,G__G__IO_261_0_6, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TBuffer' - 1 - buffer Y - - 0 - object", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("TConfiguration", 1452, G__G__IO_261_0_7, (int) ('i'), G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration), -1, 0, 1, 1, 1, 0, "u 'TStreamerInfoActions::TConfiguration' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TConfiguration", 1578, G__G__IO_261_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_261_0_9, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration), -1, 1, 1, 1, 1, 0, "u 'TStreamerInfoActions::TConfiguration' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerInfoActionscLcLTConfiguredAction(void) {
   /* TStreamerInfoActions::TConfiguredAction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction));
   G__memfunc_setup("TConfiguredAction",1720,G__G__IO_263_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TConfiguredAction",1720,G__G__IO_263_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction), -1, 0, 1, 1, 1, 0, "u 'TStreamerInfoActions::TConfiguredAction' - 11 - rval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TConfiguredAction",1720,G__G__IO_263_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction), -1, 0, 2, 1, 1, 0, 
"Y - 'TStreamerInfoActions::TStreamerInfoLoopAction_t' 0 - action U 'TStreamerInfoActions::TConfiguration' - 0 - conf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintDebug",1012,G__G__IO_263_0_4, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TBuffer' - 1 - buffer Y - - 0 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__IO_263_0_5, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"u 'TBuffer' - 1 - buffer Y - - 0 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__IO_263_0_6, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"u 'TBuffer' - 1 - buffer Y - - 0 - start_collection "
"Y - - 10 - end_collection", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__IO_263_0_7, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"u 'TBuffer' - 1 - buffer Y - - 0 - start_collection "
"Y - - 10 - end_collection U 'TStreamerInfoActions::TLoopConfiguration' - 10 - loopconf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__IO_263_0_8, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerInfoActions::TConfiguredAction::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_263_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfoActions::TConfiguredAction::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_263_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerInfoActions::TConfiguredAction::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_263_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerInfoActions::TConfiguredAction::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_263_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__IO_263_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfoActions::TConfiguredAction::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_263_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerInfoActions::TConfiguredAction::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_263_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerInfoActions::TConfiguredAction::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_263_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerInfoActions::TConfiguredAction::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TConfiguredAction", 1846, G__G__IO_263_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__IO_263_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction), -1, 1, 1, 1, 1, 0, "u 'TStreamerInfoActions::TConfiguredAction' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualObject(void) {
   /* TVirtualObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TVirtualObject));
   G__memfunc_setup("TVirtualObject",1426,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TVirtualObject), -1, 0, 1, 1, 4, 0, "u 'TVirtualObject' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TVirtualObject), -1, 1, 1, 1, 4, 0, "u 'TVirtualObject' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TVirtualObject",1426,G__G__IO_277_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TVirtualObject), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__IO_277_0_4, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__IO_277_0_5, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualObject", 1552, G__G__IO_277_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTZIPMember(void) {
   /* TZIPMember */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPMember));
   G__memfunc_setup("TZIPMember",927,G__G__IO_278_0_1, 105, G__get_linked_tagnum(&G__G__IOLN_TZIPMember), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TZIPMember",927,G__G__IO_278_0_2, 105, G__get_linked_tagnum(&G__G__IOLN_TZIPMember), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TZIPMember",927,G__G__IO_278_0_3, 105, G__get_linked_tagnum(&G__G__IOLN_TZIPMember), -1, 0, 1, 1, 1, 0, "u 'TZIPMember' - 11 - member", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__IO_278_0_4, 117, G__get_linked_tagnum(&G__G__IOLN_TZIPMember), -1, 1, 1, 1, 1, 0, "u 'TZIPMember' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocal",779,G__G__IO_278_0_5, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalLen",1066,G__G__IO_278_0_6, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobal",881,G__G__IO_278_0_7, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalLen",1168,G__G__IO_278_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCRC32",605,G__G__IO_278_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttrInt",998,G__G__IO_278_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttrExt",1004,G__G__IO_278_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__IO_278_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLevel",792,G__G__IO_278_0_13, 104, -1, G__defined_typename("UInt_t"), 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("Class",502,G__G__IO_278_0_15, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TZIPMember::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_278_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TZIPMember::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_278_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TZIPMember::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_278_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TZIPMember::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_278_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__IO_278_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TZIPMember::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_278_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TZIPMember::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_278_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TZIPMember::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_278_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TZIPMember::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TZIPMember", 1053, G__G__IO_278_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTZIPFile(void) {
   /* TZIPFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__IOLN_TZIPFile));
   G__memfunc_setup("FindEndHeader",1249,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadEndHeader",1244,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "n - 'Long64_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDirectory",1329,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadMemberHeader",1565,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TZIPMember' - 0 - member", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 2, 0, 
"Y - - 10 - buffer i - 'Int_t' 0 - bytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TZIPFile",711,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__IOLN_TZIPFile), -1, 0, 1, 1, 2, 0, "u 'TZIPFile' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__IOLN_TZIPFile), -1, 1, 1, 1, 2, 0, "u 'TZIPFile' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TZIPFile",711,G__G__IO_279_0_8, 105, G__get_linked_tagnum(&G__G__IOLN_TZIPFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TZIPFile",711,G__G__IO_279_0_9, 105, G__get_linked_tagnum(&G__G__IOLN_TZIPFile), -1, 0, 3, 1, 1, 0, 
"C - - 10 - archive C - - 10 - member "
"U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenArchive",1108,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCurrentMember",1639,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (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("Class",502,G__G__IO_279_0_13, 85, G__get_linked_tagnum(&G__G__IOLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TZIPFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__IO_279_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TZIPFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__IO_279_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TZIPFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__IO_279_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TZIPFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__IOLN_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__IO_279_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__IO_279_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TZIPFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__IO_279_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TZIPFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__IO_279_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TZIPFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__IO_279_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TZIPFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TZIPFile", 837, G__G__IO_279_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


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

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

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

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
   G__memvar_setup((void*)(&gFile),85,0,0,G__get_linked_tagnum(&G__G__IOLN_TFile),-1,-1,1,"gFile=",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__IO() {
  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() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__IO() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__IOLN_type_info = { "type_info" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TClassStreamer = { "TClassStreamer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TMemberStreamer = { "TMemberStreamer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TVirtualCollectionProxy = { "TVirtualCollectionProxy" , 99 , -1 };
G__linked_taginfo G__G__IOLN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__IOLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__IOLN_ROOTcLcLTCollectionProxyInfo = { "ROOT::TCollectionProxyInfo" , 99 , -1 };
G__linked_taginfo G__G__IOLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TVirtualStreamerInfo = { "TVirtualStreamerInfo" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerElement = { "TStreamerElement" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TProcessID = { "TProcessID" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TRefTable = { "TRefTable" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TVirtualArray = { "TVirtualArray" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfoActions = { "TStreamerInfoActions" , 110 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfoActionscLcLTActionSequence = { "TStreamerInfoActions::TActionSequence" , 99 , -1 };
G__linked_taginfo G__G__IOLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TBuffercLcLEMode = { "TBuffer::EMode" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TDatime = { "TDatime" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TArchiveMember = { "TArchiveMember" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TArchiveFile = { "TArchiveFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfo = { "TStreamerInfo" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TExMap = { "TExMap" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TBufferFile = { "TBufferFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TBufferFilecLcLdA = { "TBufferFile::$" , 101 , -1 };
G__linked_taginfo G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironBase = { "ROOT::TCollectionProxyInfo::EnvironBase" , 115 , -1 };
G__linked_taginfo G__G__IOLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__IOLN_TDataMember = { "TDataMember" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TClassRef = { "TClassRef" , 99 , -1 };
G__linked_taginfo G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_EDataType = { "EDataType" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TCollectionProxyFactory = { "TCollectionProxyFactory" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TGenCollectionProxy = { "TGenCollectionProxy" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TGenCollectionProxycLcLdA = { "TGenCollectionProxy::$" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TGenCollectionProxycLcLValue = { "TGenCollectionProxy::Value" , 115 , -1 };
G__linked_taginfo G__G__IOLN_TGenCollectionProxycLcLMethod = { "TGenCollectionProxy::Method" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TGenCollectionProxycLcLMethod0 = { "TGenCollectionProxy::Method0" , 99 , -1 };
G__linked_taginfo G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironlEcharoB64cBgR = { "ROOT::TCollectionProxyInfo::Environ<char[64]>" , 115 , -1 };
G__linked_taginfo G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR = { "vector<TGenCollectionProxy::TStaging*,allocator<TGenCollectionProxy::TStaging*> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGenCollectionProxy::TStaging*,allocator<TGenCollectionProxy::TStaging*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR = { "vector<ROOT::TCollectionProxyInfo::EnvironBase*,allocator<ROOT::TCollectionProxyInfo::EnvironBase*> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TCollectionProxyInfo::EnvironBase*,allocator<ROOT::TCollectionProxyInfo::EnvironBase*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TGenCollectionStreamer = { "TGenCollectionStreamer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TEmulatedCollectionProxy = { "TEmulatedCollectionProxy" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TCollectionStreamer = { "TCollectionStreamer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TCollectionClassStreamer = { "TCollectionClassStreamer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TCollectionMemberStreamer = { "TCollectionMemberStreamer" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TKey = { "TKey" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TDirectoryFile = { "TDirectoryFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TDirectoryFilecLcLdA = { "TDirectoryFile::$" , 101 , -1 };
G__linked_taginfo G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TEmulatedMapProxy = { "TEmulatedMapProxy" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TBranch = { "TBranch" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TFileCacheRead = { "TFileCacheRead" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TFileCacheWrite = { "TFileCacheWrite" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TUrl = { "TUrl" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TFree = { "TFree" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TArrayC = { "TArrayC" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TFileOpenHandle = { "TFileOpenHandle" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TFilecLcLEAsyncOpenStatus = { "TFile::EAsyncOpenStatus" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TFilecLcLEOpenTimeOut = { "TFile::EOpenTimeOut" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TFilecLcLEStatusBits = { "TFile::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TFilecLcLERelativeTo = { "TFile::ERelativeTo" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TFilecLcLdA = { "TFile::$" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TFilecLcLEFileType = { "TFile::EFileType" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TMapFile = { "TMapFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TKeyMapFile = { "TKeyMapFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TLockFile = { "TLockFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TMapRec = { "TMapRec" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TMapFilecLcLdA = { "TMapFile::$" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfocLcLTCompInfo = { "TStreamerInfo::TCompInfo" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfocLcLdA = { "TStreamerInfo::$" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfocLcLEReadWrite = { "TStreamerInfo::EReadWrite" , 101 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfoActionscLcLTConfiguration = { "TStreamerInfoActions::TConfiguration" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfoActionscLcLTLoopConfiguration = { "TStreamerInfoActions::TLoopConfiguration" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction = { "TStreamerInfoActions::TConfiguredAction" , 99 , -1 };
G__linked_taginfo G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR = { "vector<TStreamerInfoActions::TConfiguredAction,allocator<TStreamerInfoActions::TConfiguredAction> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfoActions::TConfiguredAction,allocator<TStreamerInfoActions::TConfiguredAction> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__IOLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TVirtualObject = { "TVirtualObject" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TZIPMember = { "TZIPMember" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TZIPFile = { "TZIPFile" , 99 , -1 };
G__linked_taginfo G__G__IOLN_TZIPFilecLcLEZIPConstants = { "TZIPFile::EZIPConstants" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__IO() {
  G__G__IOLN_type_info.tagnum = -1 ;
  G__G__IOLN_TClass.tagnum = -1 ;
  G__G__IOLN_TBuffer.tagnum = -1 ;
  G__G__IOLN_TDirectory.tagnum = -1 ;
  G__G__IOLN_TMemberInspector.tagnum = -1 ;
  G__G__IOLN_TObject.tagnum = -1 ;
  G__G__IOLN_TNamed.tagnum = -1 ;
  G__G__IOLN_TString.tagnum = -1 ;
  G__G__IOLN_TClassStreamer.tagnum = -1 ;
  G__G__IOLN_TMemberStreamer.tagnum = -1 ;
  G__G__IOLN_TVirtualCollectionProxy.tagnum = -1 ;
  G__G__IOLN_ROOT.tagnum = -1 ;
  G__G__IOLN_string.tagnum = -1 ;
  G__G__IOLN_ROOTcLcLTCollectionProxyInfo.tagnum = -1 ;
  G__G__IOLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_TList.tagnum = -1 ;
  G__G__IOLN_TBrowser.tagnum = -1 ;
  G__G__IOLN_TObjArray.tagnum = -1 ;
  G__G__IOLN_TVirtualStreamerInfo.tagnum = -1 ;
  G__G__IOLN_TStreamerElement.tagnum = -1 ;
  G__G__IOLN_TProcessID.tagnum = -1 ;
  G__G__IOLN_TClonesArray.tagnum = -1 ;
  G__G__IOLN_TRefTable.tagnum = -1 ;
  G__G__IOLN_TVirtualArray.tagnum = -1 ;
  G__G__IOLN_TStreamerInfoActions.tagnum = -1 ;
  G__G__IOLN_TStreamerInfoActionscLcLTActionSequence.tagnum = -1 ;
  G__G__IOLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_TBuffercLcLEMode.tagnum = -1 ;
  G__G__IOLN_TDatime.tagnum = -1 ;
  G__G__IOLN_TFile.tagnum = -1 ;
  G__G__IOLN_TArchiveMember.tagnum = -1 ;
  G__G__IOLN_TArchiveFile.tagnum = -1 ;
  G__G__IOLN_TStreamerInfo.tagnum = -1 ;
  G__G__IOLN_TExMap.tagnum = -1 ;
  G__G__IOLN_TBufferFile.tagnum = -1 ;
  G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_TBufferFilecLcLdA.tagnum = -1 ;
  G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironBase.tagnum = -1 ;
  G__G__IOLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__IOLN_TDataMember.tagnum = -1 ;
  G__G__IOLN_TClassRef.tagnum = -1 ;
  G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__IOLN_EDataType.tagnum = -1 ;
  G__G__IOLN_TCollectionProxyFactory.tagnum = -1 ;
  G__G__IOLN_TGenCollectionProxy.tagnum = -1 ;
  G__G__IOLN_TGenCollectionProxycLcLdA.tagnum = -1 ;
  G__G__IOLN_TGenCollectionProxycLcLValue.tagnum = -1 ;
  G__G__IOLN_TGenCollectionProxycLcLMethod.tagnum = -1 ;
  G__G__IOLN_TGenCollectionProxycLcLMethod0.tagnum = -1 ;
  G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironlEcharoB64cBgR.tagnum = -1 ;
  G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_TGenCollectionStreamer.tagnum = -1 ;
  G__G__IOLN_TEmulatedCollectionProxy.tagnum = -1 ;
  G__G__IOLN_TCollectionStreamer.tagnum = -1 ;
  G__G__IOLN_TCollectionClassStreamer.tagnum = -1 ;
  G__G__IOLN_TCollectionMemberStreamer.tagnum = -1 ;
  G__G__IOLN_TKey.tagnum = -1 ;
  G__G__IOLN_TDirectoryFile.tagnum = -1 ;
  G__G__IOLN_TDirectoryFilecLcLdA.tagnum = -1 ;
  G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_TEmulatedMapProxy.tagnum = -1 ;
  G__G__IOLN_TBranch.tagnum = -1 ;
  G__G__IOLN_TFileCacheRead.tagnum = -1 ;
  G__G__IOLN_TFileCacheWrite.tagnum = -1 ;
  G__G__IOLN_TUrl.tagnum = -1 ;
  G__G__IOLN_TFree.tagnum = -1 ;
  G__G__IOLN_TArrayC.tagnum = -1 ;
  G__G__IOLN_TFileOpenHandle.tagnum = -1 ;
  G__G__IOLN_TStopwatch.tagnum = -1 ;
  G__G__IOLN_TFilecLcLEAsyncOpenStatus.tagnum = -1 ;
  G__G__IOLN_TFilecLcLEOpenTimeOut.tagnum = -1 ;
  G__G__IOLN_TFilecLcLEStatusBits.tagnum = -1 ;
  G__G__IOLN_TFilecLcLERelativeTo.tagnum = -1 ;
  G__G__IOLN_TFilecLcLdA.tagnum = -1 ;
  G__G__IOLN_TFilecLcLEFileType.tagnum = -1 ;
  G__G__IOLN_TMapFile.tagnum = -1 ;
  G__G__IOLN_TKeyMapFile.tagnum = -1 ;
  G__G__IOLN_TLockFile.tagnum = -1 ;
  G__G__IOLN_TMapRec.tagnum = -1 ;
  G__G__IOLN_TMapFilecLcLdA.tagnum = -1 ;
  G__G__IOLN_TStreamerInfocLcLTCompInfo.tagnum = -1 ;
  G__G__IOLN_TStreamerInfocLcLdA.tagnum = -1 ;
  G__G__IOLN_TStreamerInfocLcLEReadWrite.tagnum = -1 ;
  G__G__IOLN_TStreamerInfoActionscLcLTConfiguration.tagnum = -1 ;
  G__G__IOLN_TStreamerInfoActionscLcLTLoopConfiguration.tagnum = -1 ;
  G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction.tagnum = -1 ;
  G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__IOLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__IOLN_TVirtualObject.tagnum = -1 ;
  G__G__IOLN_TZIPMember.tagnum = -1 ;
  G__G__IOLN_TZIPFile.tagnum = -1 ;
  G__G__IOLN_TZIPFilecLcLEZIPConstants.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__IO() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__IOLN_type_info);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TString);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TClassStreamer);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TMemberStreamer);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TVirtualCollectionProxy);
   G__get_linked_tagnum_fwd(&G__G__IOLN_ROOT);
   G__get_linked_tagnum_fwd(&G__G__IOLN_string);
   G__get_linked_tagnum_fwd(&G__G__IOLN_ROOTcLcLTCollectionProxyInfo);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TList);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TVirtualStreamerInfo);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerElement);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TProcessID);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TClonesArray);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TRefTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TVirtualArray),sizeof(TVirtualArray),-1,623616,(char*)NULL,G__setup_memvarTVirtualArray,G__setup_memfuncTVirtualArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfoActions),0,-1,0,(char*)NULL,G__setup_memvarTStreamerInfoActions,G__setup_memfuncTStreamerInfoActions);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfoActionscLcLTActionSequence),sizeof(TStreamerInfoActions::TActionSequence),-1,324864,(char*)NULL,G__setup_memvarTStreamerInfoActionscLcLTActionSequence,G__setup_memfuncTStreamerInfoActionscLcLTActionSequence);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TBuffercLcLEMode);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TDatime);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TFile),sizeof(TFile),-1,130816,"ROOT file",G__setup_memvarTFile,G__setup_memfuncTFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TArchiveMember),sizeof(TArchiveMember),-1,327424,"An archive member file",G__setup_memvarTArchiveMember,G__setup_memfuncTArchiveMember);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TArchiveFile),sizeof(TArchiveFile),-1,327426,"An archive file containing multiple sub-files (like a ZIP archive)",G__setup_memvarTArchiveFile,G__setup_memfuncTArchiveFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfo),sizeof(TStreamerInfo),-1,130816,"Streamer information for one class version",G__setup_memvarTStreamerInfo,G__setup_memfuncTStreamerInfo);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TExMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TBufferFile),sizeof(TBufferFile),-1,65280,"concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket.",G__setup_memvarTBufferFile,G__setup_memfuncTBufferFile);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TBufferFilecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironBase);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TDataMember);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TClassRef);
   G__get_linked_tagnum_fwd(&G__G__IOLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_EDataType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TCollectionProxyFactory),sizeof(TCollectionProxyFactory),-1,65536,(char*)NULL,G__setup_memvarTCollectionProxyFactory,G__setup_memfuncTCollectionProxyFactory);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TGenCollectionProxy),sizeof(TGenCollectionProxy),-1,100096,(char*)NULL,G__setup_memvarTGenCollectionProxy,G__setup_memfuncTGenCollectionProxy);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TGenCollectionProxycLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TGenCollectionProxycLcLValue),sizeof(TGenCollectionProxy::Value),-1,98816,(char*)NULL,G__setup_memvarTGenCollectionProxycLcLValue,G__setup_memfuncTGenCollectionProxycLcLValue);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TGenCollectionProxycLcLMethod),sizeof(TGenCollectionProxy::Method),-1,99072,(char*)NULL,G__setup_memvarTGenCollectionProxycLcLMethod,G__setup_memfuncTGenCollectionProxycLcLMethod);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TGenCollectionProxycLcLMethod0);
   G__get_linked_tagnum_fwd(&G__G__IOLN_ROOTcLcLTCollectionProxyInfocLcLEnvironlEcharoB64cBgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlETGenCollectionProxycLcLTStagingmUcOallocatorlETGenCollectionProxycLcLTStagingmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUcOallocatorlEROOTcLcLTCollectionProxyInfocLcLEnvironBasemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TGenCollectionStreamer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TEmulatedCollectionProxy),sizeof(TEmulatedCollectionProxy),-1,99840,(char*)NULL,G__setup_memvarTEmulatedCollectionProxy,G__setup_memfuncTEmulatedCollectionProxy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TCollectionStreamer),sizeof(TCollectionStreamer),-1,69376,(char*)NULL,G__setup_memvarTCollectionStreamer,G__setup_memfuncTCollectionStreamer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TCollectionClassStreamer),sizeof(TCollectionClassStreamer),-1,100096,(char*)NULL,G__setup_memvarTCollectionClassStreamer,G__setup_memfuncTCollectionClassStreamer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TCollectionMemberStreamer),sizeof(TCollectionMemberStreamer),-1,100096,(char*)NULL,G__setup_memvarTCollectionMemberStreamer,G__setup_memfuncTCollectionMemberStreamer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TKey),sizeof(TKey),-1,130816,"Header description of a logical record on file.",G__setup_memvarTKey,G__setup_memfuncTKey);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TDirectoryFile),sizeof(TDirectoryFile),-1,130816,"Describe directory structure in a ROOT file",G__setup_memvarTDirectoryFile,G__setup_memfuncTDirectoryFile);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TDirectoryFilecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlEcharcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TEmulatedMapProxy),sizeof(TEmulatedMapProxy),-1,99840,(char*)NULL,G__setup_memvarTEmulatedMapProxy,G__setup_memfuncTEmulatedMapProxy);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TBranch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TFileCacheRead),sizeof(TFileCacheRead),-1,327424,"TFile cache when reading",G__setup_memvarTFileCacheRead,G__setup_memfuncTFileCacheRead);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TFileCacheWrite),sizeof(TFileCacheWrite),-1,327424,"TFile cache when writing",G__setup_memvarTFileCacheWrite,G__setup_memfuncTFileCacheWrite);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TUrl);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TFree),sizeof(TFree),-1,62720,"Description of free segments on a file",G__setup_memvarTFree,G__setup_memfuncTFree);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TArrayC);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFileOpenHandle);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TStopwatch);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFilecLcLEAsyncOpenStatus);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFilecLcLEOpenTimeOut);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFilecLcLEStatusBits);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFilecLcLERelativeTo);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFilecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TFilecLcLEFileType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TMapFile),sizeof(TMapFile),-1,65280,"Memory mapped directory structure",G__setup_memvarTMapFile,G__setup_memfuncTMapFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TKeyMapFile),sizeof(TKeyMapFile),-1,65280,"Utility class for browsing TMapFile objects.",G__setup_memvarTKeyMapFile,G__setup_memfuncTKeyMapFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TLockFile),sizeof(TLockFile),-1,65024,"Lock an object using a file",G__setup_memvarTLockFile,G__setup_memfuncTLockFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TMapRec),sizeof(TMapRec),-1,33792,(char*)NULL,G__setup_memvarTMapRec,G__setup_memfuncTMapRec);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TMapFilecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfocLcLTCompInfo);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfocLcLdA);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfocLcLEReadWrite);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguration),sizeof(TStreamerInfoActions::TConfiguration),-1,99328,(char*)NULL,G__setup_memvarTStreamerInfoActionscLcLTConfiguration,G__setup_memfuncTStreamerInfoActionscLcLTConfiguration);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfoActionscLcLTLoopConfiguration);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TStreamerInfoActionscLcLTConfiguredAction),sizeof(TStreamerInfoActions::TConfiguredAction),-1,325376,"A configured action",G__setup_memvarTStreamerInfoActionscLcLTConfiguredAction,G__setup_memfuncTStreamerInfoActionscLcLTConfiguredAction);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlETStreamerInfoActionscLcLTConfiguredActioncOallocatorlETStreamerInfoActionscLcLTConfiguredActiongRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__IOLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TVirtualObject),sizeof(TVirtualObject),-1,626176,(char*)NULL,G__setup_memvarTVirtualObject,G__setup_memfuncTVirtualObject);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TZIPMember),sizeof(TZIPMember),-1,327424,"A ZIP archive member file",G__setup_memvarTZIPMember,G__setup_memfuncTZIPMember);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__IOLN_TZIPFile),sizeof(TZIPFile),-1,327424,"A ZIP archive file",G__setup_memvarTZIPFile,G__setup_memfuncTZIPFile);
   G__get_linked_tagnum_fwd(&G__G__IOLN_TZIPFilecLcLEZIPConstants);
}
extern "C" void G__cpp_setupG__IO(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__IO()");
  G__set_cpp_environmentG__IO();
  G__cpp_setup_tagtableG__IO();

  G__cpp_setup_inheritanceG__IO();

  G__cpp_setup_typetableG__IO();

  G__cpp_setup_memvarG__IO();

  G__cpp_setup_memfuncG__IO();
  G__cpp_setup_globalG__IO();
  G__cpp_setup_funcG__IO();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__IO();
  return;
}
class G__cpp_setup_initG__IO {
  public:
    G__cpp_setup_initG__IO() { G__add_setup_func("G__IO",(G__incsetup)(&G__cpp_setupG__IO)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__IO() { G__remove_setup_func("G__IO"); }
};
G__cpp_setup_initG__IO G__cpp_setup_initializerG__IO;

---