G__Meta.cxx

Go to the documentation of this file.

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

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

#define R__DICTIONARY_FILENAME coredImetadIsrcdIG__Meta
#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__Meta.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TClassStreamer TClassStreamer;
      #else
      class TClassStreamer  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TClassStreamer() throw() {};
         void* fStreamer; //
         ::TClassRef fOnFileClass; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMemberStreamer TMemberStreamer;
      #else
      class TMemberStreamer  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMemberStreamer() throw() {};
         void* fStreamer; //
         ::TClassRef fOnFileClass; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TClassRef TClassRef;
      #else
      class TClassRef  {
         public:
         //friend XX;
         string fClassName; //Name of referenced class
         ::TClass* fClassPtr; //! Ptr to the TClass object
         ::TClassRef* fPrevious; //! link to the previous refs
         ::TClassRef* fNext; //! link to the next refs 
      };
      #endif

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

namespace ROOT {
   void TClass_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TClass(void *p = 0);
   static void *newArray_TClass(Long_t size, void *p);
   static void delete_TClass(void *p);
   static void deleteArray_TClass(void *p);
   static void destruct_TClass(void *p);
   static void streamer_TClass(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TClass*)
   {
      ::TClass *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TClass >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TClass", ::TClass::Class_Version(), "include/TClass.h", 65,
                  typeid(::TClass), DefineBehavior(ptr, ptr),
                  &::TClass::Dictionary, isa_proxy, 0,
                  sizeof(::TClass) );
      instance.SetNew(&new_TClass);
      instance.SetNewArray(&newArray_TClass);
      instance.SetDelete(&delete_TClass);
      instance.SetDeleteArray(&deleteArray_TClass);
      instance.SetDestructor(&destruct_TClass);
      instance.SetStreamerFunc(&streamer_TClass);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TClass*)
   {
      return GenerateInitInstanceLocal((::TClass*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TClass*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TClassStreamer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TClassStreamer_Dictionary();
   static void delete_TClassStreamer(void *p);
   static void deleteArray_TClassStreamer(void *p);
   static void destruct_TClassStreamer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TClassStreamer*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TClassStreamer) == sizeof(::ROOT::Shadow::TClassStreamer));
      ::TClassStreamer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TClassStreamer),0);
      static ::ROOT::TGenericClassInfo 
         instance("TClassStreamer", "include/TClassStreamer.h", 27,
                  typeid(::TClassStreamer), DefineBehavior(ptr, ptr),
                  &TClassStreamer_ShowMembers, &TClassStreamer_Dictionary, isa_proxy, 4,
                  sizeof(::TClassStreamer) );
      instance.SetDelete(&delete_TClassStreamer);
      instance.SetDeleteArray(&deleteArray_TClassStreamer);
      instance.SetDestructor(&destruct_TClassStreamer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TClassStreamer*)
   {
      return GenerateInitInstanceLocal((::TClassStreamer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TClassStreamer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TMemberStreamer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMemberStreamer_Dictionary();
   static void delete_TMemberStreamer(void *p);
   static void deleteArray_TMemberStreamer(void *p);
   static void destruct_TMemberStreamer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMemberStreamer*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMemberStreamer) == sizeof(::ROOT::Shadow::TMemberStreamer));
      ::TMemberStreamer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMemberStreamer),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMemberStreamer", "include/TMemberStreamer.h", 27,
                  typeid(::TMemberStreamer), DefineBehavior(ptr, ptr),
                  &TMemberStreamer_ShowMembers, &TMemberStreamer_Dictionary, isa_proxy, 4,
                  sizeof(::TMemberStreamer) );
      instance.SetDelete(&delete_TMemberStreamer);
      instance.SetDeleteArray(&deleteArray_TMemberStreamer);
      instance.SetDestructor(&destruct_TMemberStreamer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMemberStreamer*)
   {
      return GenerateInitInstanceLocal((::TMemberStreamer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMemberStreamer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TVirtualIsAProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TVirtualIsAProxy_Dictionary();
   static void delete_TVirtualIsAProxy(void *p);
   static void deleteArray_TVirtualIsAProxy(void *p);
   static void destruct_TVirtualIsAProxy(void *p);

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

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

} // end of namespace ROOT

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

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("ROOT", 0 /*version*/, "include/TVirtualStreamerInfo.h", 35,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &ROOT_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 ROOT_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }

namespace ROOT {
   void TMethod_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMethod(void *p = 0);
   static void *newArray_TMethod(Long_t size, void *p);
   static void delete_TMethod(void *p);
   static void deleteArray_TMethod(void *p);
   static void destruct_TMethod(void *p);
   static void streamer_TMethod(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMethod*)
   {
      ::TMethod *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMethod >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMethod", ::TMethod::Class_Version(), "include/TMethod.h", 40,
                  typeid(::TMethod), DefineBehavior(ptr, ptr),
                  &::TMethod::Dictionary, isa_proxy, 0,
                  sizeof(::TMethod) );
      instance.SetNew(&new_TMethod);
      instance.SetNewArray(&newArray_TMethod);
      instance.SetDelete(&delete_TMethod);
      instance.SetDeleteArray(&deleteArray_TMethod);
      instance.SetDestructor(&destruct_TMethod);
      instance.SetStreamerFunc(&streamer_TMethod);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMethod*)
   {
      return GenerateInitInstanceLocal((::TMethod*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMethod*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TVirtualStreamerInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualStreamerInfo(void *p);
   static void deleteArray_TVirtualStreamerInfo(void *p);
   static void destruct_TVirtualStreamerInfo(void *p);
   static void streamer_TVirtualStreamerInfo(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TStreamerElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerElement(void *p = 0);
   static void *newArray_TStreamerElement(Long_t size, void *p);
   static void delete_TStreamerElement(void *p);
   static void deleteArray_TStreamerElement(void *p);
   static void destruct_TStreamerElement(void *p);
   static void streamer_TStreamerElement(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDictionary_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TDictionary(void *p);
   static void deleteArray_TDictionary(void *p);
   static void destruct_TDictionary(void *p);
   static void streamer_TDictionary(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TBaseClass_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBaseClass(void *p = 0);
   static void *newArray_TBaseClass(Long_t size, void *p);
   static void delete_TBaseClass(void *p);
   static void deleteArray_TBaseClass(void *p);
   static void destruct_TBaseClass(void *p);
   static void streamer_TBaseClass(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDataMember_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDataMember(void *p = 0);
   static void *newArray_TDataMember(Long_t size, void *p);
   static void delete_TDataMember(void *p);
   static void deleteArray_TDataMember(void *p);
   static void destruct_TDataMember(void *p);
   static void streamer_TDataMember(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TClassRef_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TClassRef_Dictionary();
   static void *new_TClassRef(void *p = 0);
   static void *newArray_TClassRef(Long_t size, void *p);
   static void delete_TClassRef(void *p);
   static void deleteArray_TClassRef(void *p);
   static void destruct_TClassRef(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TClassRef*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TClassRef) == sizeof(::ROOT::Shadow::TClassRef));
      ::TClassRef *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TClassRef),0);
      static ::ROOT::TGenericClassInfo 
         instance("TClassRef", "include/TClassRef.h", 33,
                  typeid(::TClassRef), DefineBehavior(ptr, ptr),
                  &TClassRef_ShowMembers, &TClassRef_Dictionary, isa_proxy, 4,
                  sizeof(::TClassRef) );
      instance.SetNew(&new_TClassRef);
      instance.SetNewArray(&newArray_TClassRef);
      instance.SetDelete(&delete_TClassRef);
      instance.SetDeleteArray(&deleteArray_TClassRef);
      instance.SetDestructor(&destruct_TClassRef);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TClassRef*)
   {
      return GenerateInitInstanceLocal((::TClassRef*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TClassRef*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TRealData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRealData(void *p = 0);
   static void *newArray_TRealData(Long_t size, void *p);
   static void delete_TRealData(void *p);
   static void deleteArray_TRealData(void *p);
   static void destruct_TRealData(void *p);

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

namespace ROOT {
   void TMethodCall_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMethodCall(void *p = 0);
   static void *newArray_TMethodCall(Long_t size, void *p);
   static void delete_TMethodCall(void *p);
   static void deleteArray_TMethodCall(void *p);
   static void destruct_TMethodCall(void *p);
   static void streamer_TMethodCall(TBuffer &buf, void *obj);

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

namespace ROOT {
   void ROOTcLcLTSchemaRuleSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_ROOTcLcLTSchemaRuleSet(void *p = 0);
   static void *newArray_ROOTcLcLTSchemaRuleSet(Long_t size, void *p);
   static void delete_ROOTcLcLTSchemaRuleSet(void *p);
   static void deleteArray_ROOTcLcLTSchemaRuleSet(void *p);
   static void destruct_ROOTcLcLTSchemaRuleSet(void *p);
   static void streamer_ROOTcLcLTSchemaRuleSet(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TClassGenerator_ShowMembers(void *obj, TMemberInspector &R__insp);

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

namespace ROOT {
   void TClassMenuItem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TClassMenuItem(void *p = 0);
   static void *newArray_TClassMenuItem(Long_t size, void *p);
   static void delete_TClassMenuItem(void *p);
   static void deleteArray_TClassMenuItem(void *p);
   static void destruct_TClassMenuItem(void *p);
   static void streamer_TClassMenuItem(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDataType_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDataType(void *p = 0);
   static void *newArray_TDataType(Long_t size, void *p);
   static void delete_TDataType(void *p);
   static void deleteArray_TDataType(void *p);
   static void destruct_TDataType(void *p);
   static void streamer_TDataType(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDataType*)
   {
      ::TDataType *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDataType >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDataType", ::TDataType::Class_Version(), "include/TDataType.h", 40,
                  typeid(::TDataType), DefineBehavior(ptr, ptr),
                  &::TDataType::Dictionary, isa_proxy, 0,
                  sizeof(::TDataType) );
      instance.SetNew(&new_TDataType);
      instance.SetNewArray(&newArray_TDataType);
      instance.SetDelete(&delete_TDataType);
      instance.SetDeleteArray(&deleteArray_TDataType);
      instance.SetDestructor(&destruct_TDataType);
      instance.SetStreamerFunc(&streamer_TDataType);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDataType*)
   {
      return GenerateInitInstanceLocal((::TDataType*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDataType*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFunction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFunction(void *p = 0);
   static void *newArray_TFunction(Long_t size, void *p);
   static void delete_TFunction(void *p);
   static void deleteArray_TFunction(void *p);
   static void destruct_TFunction(void *p);
   static void streamer_TFunction(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGlobal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGlobal(void *p = 0);
   static void *newArray_TGlobal(Long_t size, void *p);
   static void delete_TGlobal(void *p);
   static void deleteArray_TGlobal(void *p);
   static void destruct_TGlobal(void *p);
   static void streamer_TGlobal(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TInterpreter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TInterpreter(void *p);
   static void deleteArray_TInterpreter(void *p);
   static void destruct_TInterpreter(void *p);
   static void streamer_TInterpreter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TIsAProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TIsAProxy_Dictionary();
   static void delete_TIsAProxy(void *p);
   static void deleteArray_TIsAProxy(void *p);
   static void destruct_TIsAProxy(void *p);

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

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

} // end of namespace ROOT

namespace ROOT {
   void TMethodArg_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMethodArg(void *p = 0);
   static void *newArray_TMethodArg(Long_t size, void *p);
   static void delete_TMethodArg(void *p);
   static void deleteArray_TMethodArg(void *p);
   static void destruct_TMethodArg(void *p);
   static void streamer_TMethodArg(TBuffer &buf, void *obj);

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

namespace ROOT {
   void ROOTcLcLTSchemaRule_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_ROOTcLcLTSchemaRule(void *p = 0);
   static void *newArray_ROOTcLcLTSchemaRule(Long_t size, void *p);
   static void delete_ROOTcLcLTSchemaRule(void *p);
   static void deleteArray_ROOTcLcLTSchemaRule(void *p);
   static void destruct_ROOTcLcLTSchemaRule(void *p);

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

namespace ROOT {
   void ROOTcLcLTSchemaRulecLcLTSources_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_ROOTcLcLTSchemaRulecLcLTSources(void *p = 0);
   static void *newArray_ROOTcLcLTSchemaRulecLcLTSources(Long_t size, void *p);
   static void delete_ROOTcLcLTSchemaRulecLcLTSources(void *p);
   static void deleteArray_ROOTcLcLTSchemaRulecLcLTSources(void *p);
   static void destruct_ROOTcLcLTSchemaRulecLcLTSources(void *p);

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

namespace ROOT {
   void ROOTcLcLTSchemaMatch_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_ROOTcLcLTSchemaMatch(void *p = 0);
   static void *newArray_ROOTcLcLTSchemaMatch(Long_t size, void *p);
   static void delete_ROOTcLcLTSchemaMatch(void *p);
   static void deleteArray_ROOTcLcLTSchemaMatch(void *p);
   static void destruct_ROOTcLcLTSchemaMatch(void *p);

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

namespace ROOT {
   void TStreamerBasicType_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerBasicType(void *p = 0);
   static void *newArray_TStreamerBasicType(Long_t size, void *p);
   static void delete_TStreamerBasicType(void *p);
   static void deleteArray_TStreamerBasicType(void *p);
   static void destruct_TStreamerBasicType(void *p);
   static void streamer_TStreamerBasicType(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerBasicType*)
   {
      ::TStreamerBasicType *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerBasicType >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerBasicType", ::TStreamerBasicType::Class_Version(), "include/TStreamerElement.h", 226,
                  typeid(::TStreamerBasicType), DefineBehavior(ptr, ptr),
                  &::TStreamerBasicType::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerBasicType) );
      instance.SetNew(&new_TStreamerBasicType);
      instance.SetNewArray(&newArray_TStreamerBasicType);
      instance.SetDelete(&delete_TStreamerBasicType);
      instance.SetDeleteArray(&deleteArray_TStreamerBasicType);
      instance.SetDestructor(&destruct_TStreamerBasicType);
      instance.SetStreamerFunc(&streamer_TStreamerBasicType);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerBasicType*)
   {
      return GenerateInitInstanceLocal((::TStreamerBasicType*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerBasicType*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerBase(void *p = 0);
   static void *newArray_TStreamerBase(Long_t size, void *p);
   static void delete_TStreamerBase(void *p);
   static void deleteArray_TStreamerBase(void *p);
   static void destruct_TStreamerBase(void *p);
   static void streamer_TStreamerBase(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerBase*)
   {
      ::TStreamerBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerBase >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerBase", ::TStreamerBase::Class_Version(), "include/TStreamerElement.h", 121,
                  typeid(::TStreamerBase), DefineBehavior(ptr, ptr),
                  &::TStreamerBase::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerBase) );
      instance.SetNew(&new_TStreamerBase);
      instance.SetNewArray(&newArray_TStreamerBase);
      instance.SetDelete(&delete_TStreamerBase);
      instance.SetDeleteArray(&deleteArray_TStreamerBase);
      instance.SetDestructor(&destruct_TStreamerBase);
      instance.SetStreamerFunc(&streamer_TStreamerBase);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerBase*)
   {
      return GenerateInitInstanceLocal((::TStreamerBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerBasicPointer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerBasicPointer(void *p = 0);
   static void *newArray_TStreamerBasicPointer(Long_t size, void *p);
   static void delete_TStreamerBasicPointer(void *p);
   static void deleteArray_TStreamerBasicPointer(void *p);
   static void destruct_TStreamerBasicPointer(void *p);
   static void streamer_TStreamerBasicPointer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerBasicPointer*)
   {
      ::TStreamerBasicPointer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerBasicPointer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerBasicPointer", ::TStreamerBasicPointer::Class_Version(), "include/TStreamerElement.h", 157,
                  typeid(::TStreamerBasicPointer), DefineBehavior(ptr, ptr),
                  &::TStreamerBasicPointer::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerBasicPointer) );
      instance.SetNew(&new_TStreamerBasicPointer);
      instance.SetNewArray(&newArray_TStreamerBasicPointer);
      instance.SetDelete(&delete_TStreamerBasicPointer);
      instance.SetDeleteArray(&deleteArray_TStreamerBasicPointer);
      instance.SetDestructor(&destruct_TStreamerBasicPointer);
      instance.SetStreamerFunc(&streamer_TStreamerBasicPointer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerBasicPointer*)
   {
      return GenerateInitInstanceLocal((::TStreamerBasicPointer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerBasicPointer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerLoop_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerLoop(void *p = 0);
   static void *newArray_TStreamerLoop(Long_t size, void *p);
   static void delete_TStreamerLoop(void *p);
   static void deleteArray_TStreamerLoop(void *p);
   static void destruct_TStreamerLoop(void *p);
   static void streamer_TStreamerLoop(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerLoop*)
   {
      ::TStreamerLoop *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerLoop >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerLoop", ::TStreamerLoop::Class_Version(), "include/TStreamerElement.h", 192,
                  typeid(::TStreamerLoop), DefineBehavior(ptr, ptr),
                  &::TStreamerLoop::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerLoop) );
      instance.SetNew(&new_TStreamerLoop);
      instance.SetNewArray(&newArray_TStreamerLoop);
      instance.SetDelete(&delete_TStreamerLoop);
      instance.SetDeleteArray(&deleteArray_TStreamerLoop);
      instance.SetDestructor(&destruct_TStreamerLoop);
      instance.SetStreamerFunc(&streamer_TStreamerLoop);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerLoop*)
   {
      return GenerateInitInstanceLocal((::TStreamerLoop*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerLoop*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerObject(void *p = 0);
   static void *newArray_TStreamerObject(Long_t size, void *p);
   static void delete_TStreamerObject(void *p);
   static void deleteArray_TStreamerObject(void *p);
   static void destruct_TStreamerObject(void *p);
   static void streamer_TStreamerObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerObject*)
   {
      ::TStreamerObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerObject", ::TStreamerObject::Class_Version(), "include/TStreamerElement.h", 248,
                  typeid(::TStreamerObject), DefineBehavior(ptr, ptr),
                  &::TStreamerObject::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerObject) );
      instance.SetNew(&new_TStreamerObject);
      instance.SetNewArray(&newArray_TStreamerObject);
      instance.SetDelete(&delete_TStreamerObject);
      instance.SetDeleteArray(&deleteArray_TStreamerObject);
      instance.SetDestructor(&destruct_TStreamerObject);
      instance.SetStreamerFunc(&streamer_TStreamerObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerObject*)
   {
      return GenerateInitInstanceLocal((::TStreamerObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerObjectAny_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerObjectAny(void *p = 0);
   static void *newArray_TStreamerObjectAny(Long_t size, void *p);
   static void delete_TStreamerObjectAny(void *p);
   static void deleteArray_TStreamerObjectAny(void *p);
   static void destruct_TStreamerObjectAny(void *p);
   static void streamer_TStreamerObjectAny(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerObjectAny*)
   {
      ::TStreamerObjectAny *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerObjectAny >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerObjectAny", ::TStreamerObjectAny::Class_Version(), "include/TStreamerElement.h", 267,
                  typeid(::TStreamerObjectAny), DefineBehavior(ptr, ptr),
                  &::TStreamerObjectAny::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerObjectAny) );
      instance.SetNew(&new_TStreamerObjectAny);
      instance.SetNewArray(&newArray_TStreamerObjectAny);
      instance.SetDelete(&delete_TStreamerObjectAny);
      instance.SetDeleteArray(&deleteArray_TStreamerObjectAny);
      instance.SetDestructor(&destruct_TStreamerObjectAny);
      instance.SetStreamerFunc(&streamer_TStreamerObjectAny);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerObjectAny*)
   {
      return GenerateInitInstanceLocal((::TStreamerObjectAny*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerObjectAny*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerObjectPointer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerObjectPointer(void *p = 0);
   static void *newArray_TStreamerObjectPointer(Long_t size, void *p);
   static void delete_TStreamerObjectPointer(void *p);
   static void deleteArray_TStreamerObjectPointer(void *p);
   static void destruct_TStreamerObjectPointer(void *p);
   static void streamer_TStreamerObjectPointer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerObjectPointer*)
   {
      ::TStreamerObjectPointer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerObjectPointer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerObjectPointer", ::TStreamerObjectPointer::Class_Version(), "include/TStreamerElement.h", 286,
                  typeid(::TStreamerObjectPointer), DefineBehavior(ptr, ptr),
                  &::TStreamerObjectPointer::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerObjectPointer) );
      instance.SetNew(&new_TStreamerObjectPointer);
      instance.SetNewArray(&newArray_TStreamerObjectPointer);
      instance.SetDelete(&delete_TStreamerObjectPointer);
      instance.SetDeleteArray(&deleteArray_TStreamerObjectPointer);
      instance.SetDestructor(&destruct_TStreamerObjectPointer);
      instance.SetStreamerFunc(&streamer_TStreamerObjectPointer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerObjectPointer*)
   {
      return GenerateInitInstanceLocal((::TStreamerObjectPointer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerObjectPointer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerObjectAnyPointer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerObjectAnyPointer(void *p = 0);
   static void *newArray_TStreamerObjectAnyPointer(Long_t size, void *p);
   static void delete_TStreamerObjectAnyPointer(void *p);
   static void deleteArray_TStreamerObjectAnyPointer(void *p);
   static void destruct_TStreamerObjectAnyPointer(void *p);
   static void streamer_TStreamerObjectAnyPointer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerObjectAnyPointer*)
   {
      ::TStreamerObjectAnyPointer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerObjectAnyPointer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerObjectAnyPointer", ::TStreamerObjectAnyPointer::Class_Version(), "include/TStreamerElement.h", 307,
                  typeid(::TStreamerObjectAnyPointer), DefineBehavior(ptr, ptr),
                  &::TStreamerObjectAnyPointer::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerObjectAnyPointer) );
      instance.SetNew(&new_TStreamerObjectAnyPointer);
      instance.SetNewArray(&newArray_TStreamerObjectAnyPointer);
      instance.SetDelete(&delete_TStreamerObjectAnyPointer);
      instance.SetDeleteArray(&deleteArray_TStreamerObjectAnyPointer);
      instance.SetDestructor(&destruct_TStreamerObjectAnyPointer);
      instance.SetStreamerFunc(&streamer_TStreamerObjectAnyPointer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerObjectAnyPointer*)
   {
      return GenerateInitInstanceLocal((::TStreamerObjectAnyPointer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerObjectAnyPointer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerString_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerString(void *p = 0);
   static void *newArray_TStreamerString(Long_t size, void *p);
   static void delete_TStreamerString(void *p);
   static void deleteArray_TStreamerString(void *p);
   static void destruct_TStreamerString(void *p);
   static void streamer_TStreamerString(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerString*)
   {
      ::TStreamerString *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerString >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerString", ::TStreamerString::Class_Version(), "include/TStreamerElement.h", 328,
                  typeid(::TStreamerString), DefineBehavior(ptr, ptr),
                  &::TStreamerString::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerString) );
      instance.SetNew(&new_TStreamerString);
      instance.SetNewArray(&newArray_TStreamerString);
      instance.SetDelete(&delete_TStreamerString);
      instance.SetDeleteArray(&deleteArray_TStreamerString);
      instance.SetDestructor(&destruct_TStreamerString);
      instance.SetStreamerFunc(&streamer_TStreamerString);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerString*)
   {
      return GenerateInitInstanceLocal((::TStreamerString*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerString*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerSTL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerSTL(void *p = 0);
   static void *newArray_TStreamerSTL(Long_t size, void *p);
   static void delete_TStreamerSTL(void *p);
   static void deleteArray_TStreamerSTL(void *p);
   static void destruct_TStreamerSTL(void *p);
   static void streamer_TStreamerSTL(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerSTL*)
   {
      ::TStreamerSTL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerSTL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerSTL", ::TStreamerSTL::Class_Version(), "include/TStreamerElement.h", 346,
                  typeid(::TStreamerSTL), DefineBehavior(ptr, ptr),
                  &::TStreamerSTL::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerSTL) );
      instance.SetNew(&new_TStreamerSTL);
      instance.SetNewArray(&newArray_TStreamerSTL);
      instance.SetDelete(&delete_TStreamerSTL);
      instance.SetDeleteArray(&deleteArray_TStreamerSTL);
      instance.SetDestructor(&destruct_TStreamerSTL);
      instance.SetStreamerFunc(&streamer_TStreamerSTL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerSTL*)
   {
      return GenerateInitInstanceLocal((::TStreamerSTL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerSTL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerSTLstring_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStreamerSTLstring(void *p = 0);
   static void *newArray_TStreamerSTLstring(Long_t size, void *p);
   static void delete_TStreamerSTLstring(void *p);
   static void deleteArray_TStreamerSTLstring(void *p);
   static void destruct_TStreamerSTLstring(void *p);
   static void streamer_TStreamerSTLstring(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStreamerSTLstring*)
   {
      ::TStreamerSTLstring *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStreamerSTLstring >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStreamerSTLstring", ::TStreamerSTLstring::Class_Version(), "include/TStreamerElement.h", 382,
                  typeid(::TStreamerSTLstring), DefineBehavior(ptr, ptr),
                  &::TStreamerSTLstring::Dictionary, isa_proxy, 1,
                  sizeof(::TStreamerSTLstring) );
      instance.SetNew(&new_TStreamerSTLstring);
      instance.SetNewArray(&newArray_TStreamerSTLstring);
      instance.SetDelete(&delete_TStreamerSTLstring);
      instance.SetDeleteArray(&deleteArray_TStreamerSTLstring);
      instance.SetDestructor(&destruct_TStreamerSTLstring);
      instance.SetStreamerFunc(&streamer_TStreamerSTLstring);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStreamerSTLstring*)
   {
      return GenerateInitInstanceLocal((::TStreamerSTLstring*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStreamerSTLstring*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStreamerArtificial_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStreamerArtificial(void *p);
   static void deleteArray_TStreamerArtificial(void *p);
   static void destruct_TStreamerArtificial(void *p);
   static void streamer_TStreamerArtificial(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TToggle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TToggle(void *p = 0);
   static void *newArray_TToggle(Long_t size, void *p);
   static void delete_TToggle(void *p);
   static void deleteArray_TToggle(void *p);
   static void destruct_TToggle(void *p);
   static void streamer_TToggle(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TToggleGroup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TToggleGroup(void *p = 0);
   static void *newArray_TToggleGroup(Long_t size, void *p);
   static void delete_TToggleGroup(void *p);
   static void deleteArray_TToggleGroup(void *p);
   static void destruct_TToggleGroup(void *p);
   static void streamer_TToggleGroup(TBuffer &buf, void *obj);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace ROOT
      namespace ROOT {
//______________________________________________________________________________
TClass *TSchemaRule::TSources::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TSchemaRule::TSources::Class_Name()
{
   return "ROOT::TSchemaRule::TSources";
}

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

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

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

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

} // namespace ROOT
      namespace ROOT {
//______________________________________________________________________________
TClass *TSchemaMatch::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   TDictionary::Streamer(R__b);
}

//______________________________________________________________________________
void TBaseClass::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBaseClass.
      TClass *R__cl = ::TBaseClass::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassPtr", (void*)&fClassPtr);
      R__insp.InspectMember("TClassRef", (void*)&fClassPtr, "fClassPtr.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      TDictionary::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBaseClass(void *p) {
      return  p ? new(p) ::TBaseClass : new ::TBaseClass;
   }
   static void *newArray_TBaseClass(Long_t nElements, void *p) {
      return p ? new(p) ::TBaseClass[nElements] : new ::TBaseClass[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBaseClass(void *p) {
      delete ((::TBaseClass*)p);
   }
   static void deleteArray_TBaseClass(void *p) {
      delete [] ((::TBaseClass*)p);
   }
   static void destruct_TBaseClass(void *p) {
      typedef ::TBaseClass current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBaseClass(TBuffer &buf, void *obj) {
      ((::TBaseClass*)obj)->::TBaseClass::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBaseClass

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

   TDictionary::Streamer(R__b);
}

//______________________________________________________________________________
void TClass::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TClass.
      TClass *R__cl = ::TClass::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(), "*fConversionStreamerInfo", &fConversionStreamerInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRealData", &fRealData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBase", &fBase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllPubData", &fAllPubData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllPubMethod", &fAllPubMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassMenuList", &fClassMenuList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeclFileName", &fDeclFileName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImplFileName", &fImplFileName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeclFileLine", &fDeclFileLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImplFileLine", &fImplFileLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInstanceCount", &fInstanceCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOnHeap", &fOnHeap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckSum", &fCheckSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCollectionProxy", &fCollectionProxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassVersion", &fClassVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassInfo", &fClassInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContextMenuTitle", &fContextMenuTitle);
      R__insp.InspectMember(fContextMenuTitle, "fContextMenuTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeInfo", &fTypeInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShowMembers", &fShowMembers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterShowMembers", &fInterShowMembers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamer", &fStreamer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSharedLibs", &fSharedLibs);
      R__insp.InspectMember(fSharedLibs, "fSharedLibs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsA", &fIsA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalIsA", &fGlobalIsA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsAMethod", &fIsAMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNew", &fNew);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewArray", &fNewArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelete", &fDelete);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeleteArray", &fDeleteArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDestructor", &fDestructor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirAutoAdd", &fDirAutoAdd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamerFunc", &fStreamerFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizeof", &fSizeof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProperty", &fProperty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersionUsed", &fVersionUsed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOffsetStreamerSet", &fIsOffsetStreamerSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffsetStreamer", &fOffsetStreamer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStreamerType", &fStreamerType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentInfo", &fCurrentInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefStart", &fRefStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefProxy", &fRefProxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSchemaRules", &fSchemaRules);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStreamerImpl", &fStreamerImpl);
      TDictionary::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TClass(void *p) {
      return  p ? new(p) ::TClass : new ::TClass;
   }
   static void *newArray_TClass(Long_t nElements, void *p) {
      return p ? new(p) ::TClass[nElements] : new ::TClass[nElements];
   }
   // Wrapper around operator delete
   static void delete_TClass(void *p) {
      delete ((::TClass*)p);
   }
   static void deleteArray_TClass(void *p) {
      delete [] ((::TClass*)p);
   }
   static void destruct_TClass(void *p) {
      typedef ::TClass current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TClass(TBuffer &buf, void *obj) {
      ((::TClass*)obj)->::TClass::Streamer(buf);
   }
} // end of namespace ROOT for class ::TClass

//______________________________________________________________________________
namespace ROOT {
   void TClassStreamer_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TClassStreamer.
      typedef ::ROOT::Shadow::TClassStreamer ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TClassStreamer*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamer", &sobj->fStreamer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOnFileClass", (void*)&sobj->fOnFileClass);
      R__insp.InspectMember("TClassRef", (void*)&sobj->fOnFileClass, "fOnFileClass.", false);
   }

}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TClassStreamer(void *p) {
      delete ((::TClassStreamer*)p);
   }
   static void deleteArray_TClassStreamer(void *p) {
      delete [] ((::TClassStreamer*)p);
   }
   static void destruct_TClassStreamer(void *p) {
      typedef ::TClassStreamer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TClassStreamer

//______________________________________________________________________________
namespace ROOT {
   void TMemberStreamer_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMemberStreamer.
      typedef ::ROOT::Shadow::TMemberStreamer ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMemberStreamer*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamer", &sobj->fStreamer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOnFileClass", (void*)&sobj->fOnFileClass);
      R__insp.InspectMember("TClassRef", (void*)&sobj->fOnFileClass, "fOnFileClass.", false);
   }

}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMemberStreamer(void *p) {
      delete ((::TMemberStreamer*)p);
   }
   static void deleteArray_TMemberStreamer(void *p) {
      delete [] ((::TMemberStreamer*)p);
   }
   static void destruct_TMemberStreamer(void *p) {
      typedef ::TMemberStreamer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMemberStreamer

//______________________________________________________________________________
namespace ROOT {
   void TClassRef_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TClassRef.
      typedef ::ROOT::Shadow::TClassRef ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TClassRef*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", (void*)&sobj->fClassName);
      R__insp.InspectMember("string", (void*)&sobj->fClassName, "fClassName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassPtr", &sobj->fClassPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrevious", &sobj->fPrevious);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNext", &sobj->fNext);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TClassRef(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TClassRef : new ::TClassRef;
   }
   static void *newArray_TClassRef(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TClassRef[nElements] : new ::TClassRef[nElements];
   }
   // Wrapper around operator delete
   static void delete_TClassRef(void *p) {
      delete ((::TClassRef*)p);
   }
   static void deleteArray_TClassRef(void *p) {
      delete [] ((::TClassRef*)p);
   }
   static void destruct_TClassRef(void *p) {
      typedef ::TClassRef current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TClassRef

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

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

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

namespace ROOT {
} // end of namespace ROOT for class ::TClassGenerator

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

   TDictionary::Streamer(R__b);
}

//______________________________________________________________________________
void TDataMember::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDataMember.
      TClass *R__cl = ::TDataMember::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataType", &fDataType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSTLCont", &fSTLCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProperty", &fProperty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeName", &fTypeName);
      R__insp.InspectMember(fTypeName, "fTypeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFullTypeName", &fFullTypeName);
      R__insp.InspectMember(fFullTypeName, "fFullTypeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrueTypeName", &fTrueTypeName);
      R__insp.InspectMember(fTrueTypeName, "fTrueTypeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValueGetter", &fValueGetter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValueSetter", &fValueSetter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptions", &fOptions);
      TDictionary::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDataMember(void *p) {
      return  p ? new(p) ::TDataMember : new ::TDataMember;
   }
   static void *newArray_TDataMember(Long_t nElements, void *p) {
      return p ? new(p) ::TDataMember[nElements] : new ::TDataMember[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDataMember(void *p) {
      delete ((::TDataMember*)p);
   }
   static void deleteArray_TDataMember(void *p) {
      delete [] ((::TDataMember*)p);
   }
   static void destruct_TDataMember(void *p) {
      typedef ::TDataMember current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDataMember(TBuffer &buf, void *obj) {
      ((::TDataMember*)obj)->::TDataMember::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDataMember

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

   TDictionary::Streamer(R__b);
}

//______________________________________________________________________________
void TDataType::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDataType.
      TClass *R__cl = ::TDataType::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      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(), "fProperty", &fProperty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrueName", &fTrueName);
      R__insp.InspectMember(fTrueName, "fTrueName.");
      TDictionary::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDataType(void *p) {
      return  p ? new(p) ::TDataType : new ::TDataType;
   }
   static void *newArray_TDataType(Long_t nElements, void *p) {
      return p ? new(p) ::TDataType[nElements] : new ::TDataType[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDataType(void *p) {
      delete ((::TDataType*)p);
   }
   static void deleteArray_TDataType(void *p) {
      delete [] ((::TDataType*)p);
   }
   static void destruct_TDataType(void *p) {
      typedef ::TDataType current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDataType(TBuffer &buf, void *obj) {
      ((::TDataType*)obj)->::TDataType::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDataType

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

   TNamed::Streamer(R__b);
}

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

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

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

   TDictionary::Streamer(R__b);
}

//______________________________________________________________________________
void TFunction::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFunction.
      TClass *R__cl = ::TFunction::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMangledName", &fMangledName);
      R__insp.InspectMember(fMangledName, "fMangledName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignature", &fSignature);
      R__insp.InspectMember(fSignature, "fSignature.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodArgs", &fMethodArgs);
      TDictionary::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFunction(void *p) {
      return  p ? new(p) ::TFunction : new ::TFunction;
   }
   static void *newArray_TFunction(Long_t nElements, void *p) {
      return p ? new(p) ::TFunction[nElements] : new ::TFunction[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFunction(void *p) {
      delete ((::TFunction*)p);
   }
   static void deleteArray_TFunction(void *p) {
      delete [] ((::TFunction*)p);
   }
   static void destruct_TFunction(void *p) {
      typedef ::TFunction current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFunction(TBuffer &buf, void *obj) {
      ((::TFunction*)obj)->::TFunction::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFunction

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

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

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

} // namespace ROOT
namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLTSchemaMatch(void *p) {
      return  p ? new(p) ::ROOT::TSchemaMatch : new ::ROOT::TSchemaMatch;
   }
   static void *newArray_ROOTcLcLTSchemaMatch(Long_t nElements, void *p) {
      return p ? new(p) ::ROOT::TSchemaMatch[nElements] : new ::ROOT::TSchemaMatch[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLTSchemaMatch(void *p) {
      delete ((::ROOT::TSchemaMatch*)p);
   }
   static void deleteArray_ROOTcLcLTSchemaMatch(void *p) {
      delete [] ((::ROOT::TSchemaMatch*)p);
   }
   static void destruct_ROOTcLcLTSchemaMatch(void *p) {
      typedef ::ROOT::TSchemaMatch current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::TSchemaMatch

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

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

} // namespace ROOT
//______________________________________________________________________________
      namespace ROOT {
void TSchemaRule::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class ROOT::TSchemaRule.
      TClass *R__cl = ::ROOT::TSchemaRule::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.InspectMember(fVersion, "fVersion.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVersionVect", &fVersionVect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChecksum", &fChecksum);
      R__insp.InspectMember(fChecksum, "fChecksum.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChecksumVect", &fChecksumVect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSourceClass", &fSourceClass);
      R__insp.InspectMember(fSourceClass, "fSourceClass.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargetClass", &fTargetClass);
      R__insp.InspectMember(fTargetClass, "fTargetClass.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTarget", &fTarget);
      R__insp.InspectMember(fTarget, "fTarget.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTargetVect", &fTargetVect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSource", &fSource);
      R__insp.InspectMember(fSource, "fSource.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSourceVect", &fSourceVect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInclude", &fInclude);
      R__insp.InspectMember(fInclude, "fInclude.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIncludeVect", &fIncludeVect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCode", &fCode);
      R__insp.InspectMember(fCode, "fCode.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmbed", &fEmbed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadFuncPtr", &fReadFuncPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadRawFuncPtr", &fReadRawFuncPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleType", &fRuleType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAttributes", &fAttributes);
      R__insp.InspectMember(fAttributes, "fAttributes.");
      TObject::ShowMembers(R__insp);
}

} // namespace ROOT
namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLTSchemaRule(void *p) {
      return  p ? new(p) ::ROOT::TSchemaRule : new ::ROOT::TSchemaRule;
   }
   static void *newArray_ROOTcLcLTSchemaRule(Long_t nElements, void *p) {
      return p ? new(p) ::ROOT::TSchemaRule[nElements] : new ::ROOT::TSchemaRule[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLTSchemaRule(void *p) {
      delete ((::ROOT::TSchemaRule*)p);
   }
   static void deleteArray_ROOTcLcLTSchemaRule(void *p) {
      delete [] ((::ROOT::TSchemaRule*)p);
   }
   static void destruct_ROOTcLcLTSchemaRule(void *p) {
      typedef ::ROOT::TSchemaRule current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::TSchemaRule

      namespace ROOT {
//______________________________________________________________________________
void TSchemaRule::TSources::Streamer(TBuffer &R__b)
{
   // Stream an object of class ROOT::TSchemaRule::TSources.

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

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

} // namespace ROOT
namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLTSchemaRulecLcLTSources(void *p) {
      return  p ? new(p) ::ROOT::TSchemaRule::TSources : new ::ROOT::TSchemaRule::TSources;
   }
   static void *newArray_ROOTcLcLTSchemaRulecLcLTSources(Long_t nElements, void *p) {
      return p ? new(p) ::ROOT::TSchemaRule::TSources[nElements] : new ::ROOT::TSchemaRule::TSources[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLTSchemaRulecLcLTSources(void *p) {
      delete ((::ROOT::TSchemaRule::TSources*)p);
   }
   static void deleteArray_ROOTcLcLTSchemaRulecLcLTSources(void *p) {
      delete [] ((::ROOT::TSchemaRule::TSources*)p);
   }
   static void destruct_ROOTcLcLTSchemaRulecLcLTSources(void *p) {
      typedef ::ROOT::TSchemaRule::TSources current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::TSchemaRule::TSources

//______________________________________________________________________________
      namespace ROOT {
void TSchemaRuleSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class ROOT::TSchemaRuleSet.
      TClass *R__cl = ::ROOT::TSchemaRuleSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPersistentRules", &fPersistentRules);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRemainingRules", &fRemainingRules);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllRules", &fAllRules);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", (void*)&fClass);
      R__insp.InspectMember("TClassRef", (void*)&fClass, "fClass.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckSum", &fCheckSum);
      TObject::ShowMembers(R__insp);
}

} // namespace ROOT
namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLTSchemaRuleSet(void *p) {
      return  p ? new(p) ::ROOT::TSchemaRuleSet : new ::ROOT::TSchemaRuleSet;
   }
   static void *newArray_ROOTcLcLTSchemaRuleSet(Long_t nElements, void *p) {
      return p ? new(p) ::ROOT::TSchemaRuleSet[nElements] : new ::ROOT::TSchemaRuleSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLTSchemaRuleSet(void *p) {
      delete ((::ROOT::TSchemaRuleSet*)p);
   }
   static void deleteArray_ROOTcLcLTSchemaRuleSet(void *p) {
      delete [] ((::ROOT::TSchemaRuleSet*)p);
   }
   static void destruct_ROOTcLcLTSchemaRuleSet(void *p) {
      typedef ::ROOT::TSchemaRuleSet current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ROOTcLcLTSchemaRuleSet(TBuffer &buf, void *obj) {
      ((::ROOT::TSchemaRuleSet*)obj)->::ROOT::TSchemaRuleSet::Streamer(buf);
   }
} // end of namespace ROOT for class ::ROOT::TSchemaRuleSet

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

   TDictionary::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGlobal(void *p) {
      return  p ? new(p) ::TGlobal : new ::TGlobal;
   }
   static void *newArray_TGlobal(Long_t nElements, void *p) {
      return p ? new(p) ::TGlobal[nElements] : new ::TGlobal[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGlobal(void *p) {
      delete ((::TGlobal*)p);
   }
   static void deleteArray_TGlobal(void *p) {
      delete [] ((::TGlobal*)p);
   }
   static void destruct_TGlobal(void *p) {
      typedef ::TGlobal current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGlobal(TBuffer &buf, void *obj) {
      ((::TGlobal*)obj)->::TGlobal::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGlobal

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

   TFunction::Streamer(R__b);
}

//______________________________________________________________________________
void TMethod::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMethod.
      TClass *R__cl = ::TMethod::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMenuItem", &fMenuItem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGetter", &fGetter);
      R__insp.InspectMember(fGetter, "fGetter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGetterMethod", &fGetterMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSetterMethod", &fSetterMethod);
      TFunction::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMethod(void *p) {
      return  p ? new(p) ::TMethod : new ::TMethod;
   }
   static void *newArray_TMethod(Long_t nElements, void *p) {
      return p ? new(p) ::TMethod[nElements] : new ::TMethod[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMethod(void *p) {
      delete ((::TMethod*)p);
   }
   static void deleteArray_TMethod(void *p) {
      delete [] ((::TMethod*)p);
   }
   static void destruct_TMethod(void *p) {
      typedef ::TMethod current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMethod(TBuffer &buf, void *obj) {
      ((::TMethod*)obj)->::TMethod::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMethod

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

   TDictionary::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMethodArg(void *p) {
      return  p ? new(p) ::TMethodArg : new ::TMethodArg;
   }
   static void *newArray_TMethodArg(Long_t nElements, void *p) {
      return p ? new(p) ::TMethodArg[nElements] : new ::TMethodArg[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMethodArg(void *p) {
      delete ((::TMethodArg*)p);
   }
   static void deleteArray_TMethodArg(void *p) {
      delete [] ((::TMethodArg*)p);
   }
   static void destruct_TMethodArg(void *p) {
      typedef ::TMethodArg current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMethodArg(TBuffer &buf, void *obj) {
      ((::TMethodArg*)obj)->::TMethodArg::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMethodArg

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TMethodCall::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMethodCall.
      TClass *R__cl = ::TMethodCall::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc", &fFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMetPtr", &fMetPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethod", &fMethod);
      R__insp.InspectMember(fMethod, "fMethod.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParams", &fParams);
      R__insp.InspectMember(fParams, "fParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProto", &fProto);
      R__insp.InspectMember(fProto, "fProto.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDtorOnly", &fDtorOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRetType", &fRetType);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMethodCall(void *p) {
      return  p ? new(p) ::TMethodCall : new ::TMethodCall;
   }
   static void *newArray_TMethodCall(Long_t nElements, void *p) {
      return p ? new(p) ::TMethodCall[nElements] : new ::TMethodCall[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMethodCall(void *p) {
      delete ((::TMethodCall*)p);
   }
   static void deleteArray_TMethodCall(void *p) {
      delete [] ((::TMethodCall*)p);
   }
   static void destruct_TMethodCall(void *p) {
      typedef ::TMethodCall current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMethodCall(TBuffer &buf, void *obj) {
      ((::TMethodCall*)obj)->::TMethodCall::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMethodCall

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

   TNamed::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TClassMenuItem::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TClassMenuItem.
      TClass *R__cl = ::TClassMenuItem::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelfObjectPos", &fSelfObjectPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelf", &fSelf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToggle", &fToggle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
      R__insp.InspectMember(fTitle, "fTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCalledObject", &fCalledObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFunctionName", &fFunctionName);
      R__insp.InspectMember(fFunctionName, "fFunctionName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArgs", &fArgs);
      R__insp.InspectMember(fArgs, "fArgs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSubMenu", &fSubMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TClassMenuItem(void *p) {
      return  p ? new(p) ::TClassMenuItem : new ::TClassMenuItem;
   }
   static void *newArray_TClassMenuItem(Long_t nElements, void *p) {
      return p ? new(p) ::TClassMenuItem[nElements] : new ::TClassMenuItem[nElements];
   }
   // Wrapper around operator delete
   static void delete_TClassMenuItem(void *p) {
      delete ((::TClassMenuItem*)p);
   }
   static void deleteArray_TClassMenuItem(void *p) {
      delete [] ((::TClassMenuItem*)p);
   }
   static void destruct_TClassMenuItem(void *p) {
      typedef ::TClassMenuItem current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TClassMenuItem(TBuffer &buf, void *obj) {
      ((::TClassMenuItem*)obj)->::TClassMenuItem::Streamer(buf);
   }
} // end of namespace ROOT for class ::TClassMenuItem

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualIsAProxy(void *p) {
      delete ((::TVirtualIsAProxy*)p);
   }
   static void deleteArray_TVirtualIsAProxy(void *p) {
      delete [] ((::TVirtualIsAProxy*)p);
   }
   static void destruct_TVirtualIsAProxy(void *p) {
      typedef ::TVirtualIsAProxy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualIsAProxy

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TIsAProxy(void *p) {
      delete ((::TIsAProxy*)p);
   }
   static void deleteArray_TIsAProxy(void *p) {
      delete [] ((::TIsAProxy*)p);
   }
   static void destruct_TIsAProxy(void *p) {
      typedef ::TIsAProxy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TIsAProxy

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRealData(void *p) {
      return  p ? new(p) ::TRealData : new ::TRealData;
   }
   static void *newArray_TRealData(Long_t nElements, void *p) {
      return p ? new(p) ::TRealData[nElements] : new ::TRealData[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRealData(void *p) {
      delete ((::TRealData*)p);
   }
   static void deleteArray_TRealData(void *p) {
      delete [] ((::TRealData*)p);
   }
   static void destruct_TRealData(void *p) {
      typedef ::TRealData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRealData

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerBase(void *p) {
      return  p ? new(p) ::TStreamerBase : new ::TStreamerBase;
   }
   static void *newArray_TStreamerBase(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerBase[nElements] : new ::TStreamerBase[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerBase(void *p) {
      delete ((::TStreamerBase*)p);
   }
   static void deleteArray_TStreamerBase(void *p) {
      delete [] ((::TStreamerBase*)p);
   }
   static void destruct_TStreamerBase(void *p) {
      typedef ::TStreamerBase current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerBase(TBuffer &buf, void *obj) {
      ((::TStreamerBase*)obj)->::TStreamerBase::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerBase

//______________________________________________________________________________
void TStreamerBasicPointer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStreamerBasicPointer.
      TClass *R__cl = ::TStreamerBasicPointer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCountVersion", &fCountVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCountName", &fCountName);
      R__insp.InspectMember(fCountName, "fCountName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCountClass", &fCountClass);
      R__insp.InspectMember(fCountClass, "fCountClass.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCounter", &fCounter);
      TStreamerElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerBasicPointer(void *p) {
      return  p ? new(p) ::TStreamerBasicPointer : new ::TStreamerBasicPointer;
   }
   static void *newArray_TStreamerBasicPointer(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerBasicPointer[nElements] : new ::TStreamerBasicPointer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerBasicPointer(void *p) {
      delete ((::TStreamerBasicPointer*)p);
   }
   static void deleteArray_TStreamerBasicPointer(void *p) {
      delete [] ((::TStreamerBasicPointer*)p);
   }
   static void destruct_TStreamerBasicPointer(void *p) {
      typedef ::TStreamerBasicPointer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerBasicPointer(TBuffer &buf, void *obj) {
      ((::TStreamerBasicPointer*)obj)->::TStreamerBasicPointer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerBasicPointer

//______________________________________________________________________________
void TStreamerLoop::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStreamerLoop.
      TClass *R__cl = ::TStreamerLoop::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCountVersion", &fCountVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCountName", &fCountName);
      R__insp.InspectMember(fCountName, "fCountName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCountClass", &fCountClass);
      R__insp.InspectMember(fCountClass, "fCountClass.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCounter", &fCounter);
      TStreamerElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerLoop(void *p) {
      return  p ? new(p) ::TStreamerLoop : new ::TStreamerLoop;
   }
   static void *newArray_TStreamerLoop(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerLoop[nElements] : new ::TStreamerLoop[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerLoop(void *p) {
      delete ((::TStreamerLoop*)p);
   }
   static void deleteArray_TStreamerLoop(void *p) {
      delete [] ((::TStreamerLoop*)p);
   }
   static void destruct_TStreamerLoop(void *p) {
      typedef ::TStreamerLoop current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerLoop(TBuffer &buf, void *obj) {
      ((::TStreamerLoop*)obj)->::TStreamerLoop::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerLoop

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerBasicType(void *p) {
      return  p ? new(p) ::TStreamerBasicType : new ::TStreamerBasicType;
   }
   static void *newArray_TStreamerBasicType(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerBasicType[nElements] : new ::TStreamerBasicType[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerBasicType(void *p) {
      delete ((::TStreamerBasicType*)p);
   }
   static void deleteArray_TStreamerBasicType(void *p) {
      delete [] ((::TStreamerBasicType*)p);
   }
   static void destruct_TStreamerBasicType(void *p) {
      typedef ::TStreamerBasicType current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerBasicType(TBuffer &buf, void *obj) {
      ((::TStreamerBasicType*)obj)->::TStreamerBasicType::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerBasicType

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerObject(void *p) {
      return  p ? new(p) ::TStreamerObject : new ::TStreamerObject;
   }
   static void *newArray_TStreamerObject(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerObject[nElements] : new ::TStreamerObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerObject(void *p) {
      delete ((::TStreamerObject*)p);
   }
   static void deleteArray_TStreamerObject(void *p) {
      delete [] ((::TStreamerObject*)p);
   }
   static void destruct_TStreamerObject(void *p) {
      typedef ::TStreamerObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerObject(TBuffer &buf, void *obj) {
      ((::TStreamerObject*)obj)->::TStreamerObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerObject

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerObjectAny(void *p) {
      return  p ? new(p) ::TStreamerObjectAny : new ::TStreamerObjectAny;
   }
   static void *newArray_TStreamerObjectAny(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerObjectAny[nElements] : new ::TStreamerObjectAny[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerObjectAny(void *p) {
      delete ((::TStreamerObjectAny*)p);
   }
   static void deleteArray_TStreamerObjectAny(void *p) {
      delete [] ((::TStreamerObjectAny*)p);
   }
   static void destruct_TStreamerObjectAny(void *p) {
      typedef ::TStreamerObjectAny current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerObjectAny(TBuffer &buf, void *obj) {
      ((::TStreamerObjectAny*)obj)->::TStreamerObjectAny::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerObjectAny

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerObjectPointer(void *p) {
      return  p ? new(p) ::TStreamerObjectPointer : new ::TStreamerObjectPointer;
   }
   static void *newArray_TStreamerObjectPointer(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerObjectPointer[nElements] : new ::TStreamerObjectPointer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerObjectPointer(void *p) {
      delete ((::TStreamerObjectPointer*)p);
   }
   static void deleteArray_TStreamerObjectPointer(void *p) {
      delete [] ((::TStreamerObjectPointer*)p);
   }
   static void destruct_TStreamerObjectPointer(void *p) {
      typedef ::TStreamerObjectPointer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerObjectPointer(TBuffer &buf, void *obj) {
      ((::TStreamerObjectPointer*)obj)->::TStreamerObjectPointer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerObjectPointer

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerObjectAnyPointer(void *p) {
      return  p ? new(p) ::TStreamerObjectAnyPointer : new ::TStreamerObjectAnyPointer;
   }
   static void *newArray_TStreamerObjectAnyPointer(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerObjectAnyPointer[nElements] : new ::TStreamerObjectAnyPointer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerObjectAnyPointer(void *p) {
      delete ((::TStreamerObjectAnyPointer*)p);
   }
   static void deleteArray_TStreamerObjectAnyPointer(void *p) {
      delete [] ((::TStreamerObjectAnyPointer*)p);
   }
   static void destruct_TStreamerObjectAnyPointer(void *p) {
      typedef ::TStreamerObjectAnyPointer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerObjectAnyPointer(TBuffer &buf, void *obj) {
      ((::TStreamerObjectAnyPointer*)obj)->::TStreamerObjectAnyPointer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerObjectAnyPointer

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerString(void *p) {
      return  p ? new(p) ::TStreamerString : new ::TStreamerString;
   }
   static void *newArray_TStreamerString(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerString[nElements] : new ::TStreamerString[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerString(void *p) {
      delete ((::TStreamerString*)p);
   }
   static void deleteArray_TStreamerString(void *p) {
      delete [] ((::TStreamerString*)p);
   }
   static void destruct_TStreamerString(void *p) {
      typedef ::TStreamerString current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerString(TBuffer &buf, void *obj) {
      ((::TStreamerString*)obj)->::TStreamerString::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerString

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerSTL(void *p) {
      return  p ? new(p) ::TStreamerSTL : new ::TStreamerSTL;
   }
   static void *newArray_TStreamerSTL(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerSTL[nElements] : new ::TStreamerSTL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerSTL(void *p) {
      delete ((::TStreamerSTL*)p);
   }
   static void deleteArray_TStreamerSTL(void *p) {
      delete [] ((::TStreamerSTL*)p);
   }
   static void destruct_TStreamerSTL(void *p) {
      typedef ::TStreamerSTL current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerSTL(TBuffer &buf, void *obj) {
      ((::TStreamerSTL*)obj)->::TStreamerSTL::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerSTL

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerSTLstring(void *p) {
      return  p ? new(p) ::TStreamerSTLstring : new ::TStreamerSTLstring;
   }
   static void *newArray_TStreamerSTLstring(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerSTLstring[nElements] : new ::TStreamerSTLstring[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerSTLstring(void *p) {
      delete ((::TStreamerSTLstring*)p);
   }
   static void deleteArray_TStreamerSTLstring(void *p) {
      delete [] ((::TStreamerSTLstring*)p);
   }
   static void destruct_TStreamerSTLstring(void *p) {
      typedef ::TStreamerSTLstring current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerSTLstring(TBuffer &buf, void *obj) {
      ((::TStreamerSTLstring*)obj)->::TStreamerSTLstring::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerSTLstring

//______________________________________________________________________________
void TStreamerElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStreamerElement.
      TClass *R__cl = ::TStreamerElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArrayLength", &fArrayLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArrayDim", &fArrayDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIndex[5]", fMaxIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTObjectOffset", &fTObjectOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewType", &fNewType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeName", &fTypeName);
      R__insp.InspectMember(fTypeName, "fTypeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassObject", &fClassObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewClass", &fNewClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamer", &fStreamer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFactor", &fFactor);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStreamerElement(void *p) {
      return  p ? new(p) ::TStreamerElement : new ::TStreamerElement;
   }
   static void *newArray_TStreamerElement(Long_t nElements, void *p) {
      return p ? new(p) ::TStreamerElement[nElements] : new ::TStreamerElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStreamerElement(void *p) {
      delete ((::TStreamerElement*)p);
   }
   static void deleteArray_TStreamerElement(void *p) {
      delete [] ((::TStreamerElement*)p);
   }
   static void destruct_TStreamerElement(void *p) {
      typedef ::TStreamerElement current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStreamerElement(TBuffer &buf, void *obj) {
      ((::TStreamerElement*)obj)->::TStreamerElement::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStreamerElement

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TToggle::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TToggle.
      TClass *R__cl = ::TToggle::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOnValue", &fOnValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffValue", &fOffValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitialized", &fInitialized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGetter", &fGetter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSetter", &fSetter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTglVariable", &fTglVariable);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TToggle(void *p) {
      return  p ? new(p) ::TToggle : new ::TToggle;
   }
   static void *newArray_TToggle(Long_t nElements, void *p) {
      return p ? new(p) ::TToggle[nElements] : new ::TToggle[nElements];
   }
   // Wrapper around operator delete
   static void delete_TToggle(void *p) {
      delete ((::TToggle*)p);
   }
   static void deleteArray_TToggle(void *p) {
      delete [] ((::TToggle*)p);
   }
   static void destruct_TToggle(void *p) {
      typedef ::TToggle current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TToggle(TBuffer &buf, void *obj) {
      ((::TToggle*)obj)->::TToggle::Streamer(buf);
   }
} // end of namespace ROOT for class ::TToggle

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

   TNamed::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TToggleGroup(void *p) {
      return  p ? new(p) ::TToggleGroup : new ::TToggleGroup;
   }
   static void *newArray_TToggleGroup(Long_t nElements, void *p) {
      return p ? new(p) ::TToggleGroup[nElements] : new ::TToggleGroup[nElements];
   }
   // Wrapper around operator delete
   static void delete_TToggleGroup(void *p) {
      delete ((::TToggleGroup*)p);
   }
   static void deleteArray_TToggleGroup(void *p) {
      delete [] ((::TToggleGroup*)p);
   }
   static void destruct_TToggleGroup(void *p) {
      typedef ::TToggleGroup current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TToggleGroup(TBuffer &buf, void *obj) {
      ((::TToggleGroup*)obj)->::TToggleGroup::Streamer(buf);
   }
} // end of namespace ROOT for class ::TToggleGroup

namespace ROOT {
   void vectorlEpairlEintcOintgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEpairlEintcOintgRsPgR_Dictionary();
   static void *new_vectorlEpairlEintcOintgRsPgR(void *p = 0);
   static void *newArray_vectorlEpairlEintcOintgRsPgR(Long_t size, void *p);
   static void delete_vectorlEpairlEintcOintgRsPgR(void *p);
   static void deleteArray_vectorlEpairlEintcOintgRsPgR(void *p);
   static void destruct_vectorlEpairlEintcOintgRsPgR(void *p);

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

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEpairlEintcOintgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,int> > : new vector<pair<int,int> >;
   }
   static void *newArray_vectorlEpairlEintcOintgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,int> >[nElements] : new vector<pair<int,int> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEpairlEintcOintgRsPgR(void *p) {
      delete ((vector<pair<int,int> >*)p);
   }
   static void deleteArray_vectorlEpairlEintcOintgRsPgR(void *p) {
      delete [] ((vector<pair<int,int> >*)p);
   }
   static void destruct_vectorlEpairlEintcOintgRsPgR(void *p) {
      typedef vector<pair<int,int> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<pair<int,int> >

/********************************************************
* core/meta/src/G__Meta.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__Meta();

extern "C" void G__set_cpp_environmentG__Meta() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TBaseClass.h");
  G__add_compiledheader("TClassGenerator.h");
  G__add_compiledheader("TClass.h");
  G__add_compiledheader("TClassMenuItem.h");
  G__add_compiledheader("TClassRef.h");
  G__add_compiledheader("TClassStreamer.h");
  G__add_compiledheader("TDataMember.h");
  G__add_compiledheader("TDataType.h");
  G__add_compiledheader("TDictionary.h");
  G__add_compiledheader("TFunction.h");
  G__add_compiledheader("TGenericClassInfo.h");
  G__add_compiledheader("TGlobal.h");
  G__add_compiledheader("TInterpreter.h");
  G__add_compiledheader("TIsAProxy.h");
  G__add_compiledheader("TMemberStreamer.h");
  G__add_compiledheader("TMethodArg.h");
  G__add_compiledheader("TMethodCall.h");
  G__add_compiledheader("TMethod.h");
  G__add_compiledheader("TRealData.h");
  G__add_compiledheader("TSchemaHelper.h");
  G__add_compiledheader("TSchemaRule.h");
  G__add_compiledheader("TSchemaRuleSet.h");
  G__add_compiledheader("TStreamerElement.h");
  G__add_compiledheader("TStreamer.h");
  G__add_compiledheader("TToggleGroup.h");
  G__add_compiledheader("TToggle.h");
  G__add_compiledheader("TVirtualIsAProxy.h");
  G__add_compiledheader("TVirtualRefProxy.h");
  G__add_compiledheader("TVirtualStreamerInfo.h");
  G__cpp_reset_tagtableG__Meta();
}
#include <new>
extern "C" int G__cpp_dllrevG__Meta() { return(30051515); }

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

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

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

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

static int G__G__Meta_6_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TClass* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TClass));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Meta_6_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->AdoptSchemaRules((ROOT::TSchemaRuleSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Meta_6_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((const TClass*) G__getstructoffset())->CallShowMembers((void*) G__int(libp->para[0]), *(TMemberInspector*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const TClass*) G__getstructoffset())->CallShowMembers((void*) G__int(libp->para[0]), *(TMemberInspector*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Meta_6_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->CopyCollectionProxy(*(TVirtualCollectionProxy*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Meta_6_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 89, (long) ((const TClass*) G__getstructoffset())->New((void*) G__int(libp->para[0]), (TClass::ENewType) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 89, (long) ((const TClass*) G__getstructoffset())->New((void*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_6_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 89, (long) ((const TClass*) G__getstructoffset())->NewArray((Long_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass::ENewType) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 89, (long) ((const TClass*) G__getstructoffset())->NewArray((Long_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__Meta_6_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetCollectionProxy(*(ROOT::TCollectionProxyInfo*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Meta_6_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetDelete((ROOT::DelFunc_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_6_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetDeleteArray((ROOT::DelArrFunc_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_6_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetDirectoryAutoAdd((ROOT::DirAutoAdd_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_6_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetDestructor((ROOT::DesFunc_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_6_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetNew((ROOT::NewFunc_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_6_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClass*) G__getstructoffset())->SetNewArray((ROOT::NewArrFunc_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Meta_6_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TClass*) G__getstructoffset())->WriteBuffer(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TClass*) G__getstructoffset())->WriteBuffer(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Meta_6_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) TClass::GetClass((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, 85, (long) TClass::GetClass((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TClass::GetClass((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_6_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) TClass::GetClass(*(type_info*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TClass::GetClass(*(type_info*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TClass::GetClass(*(type_info*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_6_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TClass::GetDict(*(type_info*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_6_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TClass::AutoBrowse((TObject*) G__int(libp->para[0]), (TBrowser*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Meta_15_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClassStreamer*) 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__Meta_15_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TClassStreamer*) G__getstructoffset())->Stream(*(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) ;
}

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

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


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

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

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

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

static int G__G__Meta_16_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMemberStreamer*) G__getstructoffset())->operator()(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMemberStreamer*) G__getstructoffset())->operator()(*(TBuffer*) libp->para[0].ref, (void*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

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

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


/* ROOT */
static int G__G__Meta_19_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ROOT::CreateClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_19_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::AddClass((const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (VoidFuncPtr_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_19_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::ResetClassVersion((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Short_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Meta_19_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ROOT::CreateClass((const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TVirtualStreamerInfo */
static int G__G__Meta_84_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualStreamerInfo*) G__getstructoffset())->Build();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Meta_84_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualStreamerInfo*) G__getstructoffset())->CompareContent((TClass*) G__int(libp->para[0]), (TVirtualStreamerInfo*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Meta_84_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TVirtualStreamerInfo*) G__getstructoffset())->GenerateHeaderFile((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (TList*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TVirtualStreamerInfo*) G__getstructoffset())->GenerateHeaderFile((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TVirtualStreamerInfo*) G__getstructoffset())->GenerateHeaderFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TDictionary */
static int G__G__Meta_111_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TDictionary*) G__getstructoffset())->Property());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Meta_123_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TDataMember*) G__getstructoffset())->GetOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_123_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TDataMember*) G__getstructoffset())->GetOffsetCint());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

static int G__G__Meta_124_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TClassRef*) G__getstructoffset())->operator ::TClass*());
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

static int G__G__Meta_125_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TRealData*) G__getstructoffset())->GetThisOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Meta_127_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Init((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_127_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->InitWithPrototype((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Meta_127_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->SetParam((ULong64_t) G__ULonglong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Meta_127_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((void*) G__int(libp->para[0]), *(Long_t*) G__Longref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_127_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(Long_t*) G__Longref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_127_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((void*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_127_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_127_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (char**) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Meta_127_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute(*(Long_t*) G__Longref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_127_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((const char*) G__int(libp->para[0]), *(Long_t*) G__Longref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_127_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute(*(Double_t*) G__Doubleref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_127_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodCall*) G__getstructoffset())->Execute((const char*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Meta_130_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((ROOT::TSchemaRuleSet*) G__getstructoffset())->AddRule((ROOT::TSchemaRule*) G__int(libp->para[0]), (ROOT::TSchemaRuleSet::EConsistencyCheck) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((ROOT::TSchemaRuleSet*) G__getstructoffset())->AddRule((ROOT::TSchemaRule*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((ROOT::TSchemaRuleSet*) G__getstructoffset())->AddRules((ROOT::TSchemaRuleSet*) G__int(libp->para[0]), (ROOT::TSchemaRuleSet::EConsistencyCheck) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((ROOT::TSchemaRuleSet*) G__getstructoffset())->AddRules((ROOT::TSchemaRuleSet*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->HasRuleWithSourceClass(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->FindRules(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->FindRules(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->FindRules(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->FindRules(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_130_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->GetClassCheckSum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->GetClassName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->GetClassVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->GetRules());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->GetPersistentRules());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRuleSet*) G__getstructoffset())->RemoveRule((ROOT::TSchemaRule*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRuleSet*) G__getstructoffset())->RemoveRules((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRuleSet*) G__getstructoffset())->SetClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_130_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::TSchemaRuleSet*) G__getstructoffset())->AsString(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Meta_148_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TClassGenerator*) G__getstructoffset())->GetClass(*(type_info*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Meta_148_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TClassGenerator*) G__getstructoffset())->GetClass(*(type_info*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__G__Meta_152_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDataType::GetTypeName((EDataType) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_152_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDataType::GetType(*(type_info*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Meta_160_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TInterpreter*) G__getstructoffset())->GetRootMapFiles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->InitializeDictionaries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->IsLoaded((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->Load((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TInterpreter*) G__getstructoffset())->LoadMacro((const char*) G__int(libp->para[0]), (TInterpreter::EErrorCode*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TInterpreter*) G__getstructoffset())->LoadMacro((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->LoadLibraryMap((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->LoadLibraryMap());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->RescanLibraryMap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->ReloadAllSharedLibraryMaps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->UnloadAllSharedLibraryMaps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->UnloadLibraryMap((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0]), (TInterpreter::EErrorCode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->ProcessLineSynch((const char*) G__int(libp->para[0]), (TInterpreter::EErrorCode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->ProcessLineSynch((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->PrintIntro();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->SetGetline((char *(*)(const char* prompt)) G__int(libp->para[0]), (void (*)(char* line)) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->ResetAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->ResetGlobals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->RewindDictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TInterpreter*) G__getstructoffset())->DeleteGlobal((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->SaveContext();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->SaveGlobalsContext();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->UpdateListOfGlobals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->UpdateListOfGlobalFunctions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->UpdateListOfTypes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TInterpreter*) G__getstructoffset())->SetClassInfo((TClass*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TInterpreter*) G__getstructoffset())->SetClassInfo((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TInterpreter*) G__getstructoffset())->CheckClassInfo((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TInterpreter*) G__getstructoffset())->CheckClassInfo((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->Calc((const char*) G__int(libp->para[0]), (TInterpreter::EErrorCode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->Calc((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->CreateListOfBaseClasses((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->CreateListOfDataMembers((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->CreateListOfMethods((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->CreateListOfMethodArgs((TFunction*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->UpdateListOfMethods((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TInterpreter*) G__getstructoffset())->GetMangledName((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TInterpreter*) G__getstructoffset())->GetMangledNameWithPrototype((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 67, (long) ((TInterpreter*) G__getstructoffset())->GetInterpreterTypeName((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 67, (long) ((TInterpreter*) G__getstructoffset())->GetInterpreterTypeName((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TInterpreter*) G__getstructoffset())->GetInterfaceMethod((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TInterpreter*) G__getstructoffset())->GetInterfaceMethodWithPrototype((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TInterpreter*) G__getstructoffset())->Execute((TObject*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (int*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TInterpreter*) G__getstructoffset())->Execute((TObject*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TInterpreter*) G__getstructoffset())->Execute((TObject*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (TMethod*) G__int(libp->para[2]), (TObjArray*) G__int(libp->para[3])
, (int*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TInterpreter*) G__getstructoffset())->Execute((TObject*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (TMethod*) G__int(libp->para[2]), (TObjArray*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->ExecuteMacro((const char*) G__int(libp->para[0]), (TInterpreter::EErrorCode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TInterpreter*) G__getstructoffset())->ExecuteMacro((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->IsErrorMessagesEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TInterpreter*) G__getstructoffset())->SetErrorMessages((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TInterpreter*) G__getstructoffset())->SetErrorMessages());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->IsProcessLineLocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TInterpreter*) G__getstructoffset())->SetProcessLineLock((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TInterpreter*) G__getstructoffset())->SetProcessLineLock();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TInterpreter*) G__getstructoffset())->TypeName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->DisplayClass((FILE*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->DisplayIncludePath((FILE*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->FindSym((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->GenericError((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->GetExecByteCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->Getgvp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->Getp2f2funcname((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->GetTopLevelMacroName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->GetCurrentMacroName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->GetSecurityError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->LoadFile((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->LoadText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MapCppName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->SetAlloclockfunc((void (*)()) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->SetAllocunlockfunc((void (*)()) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->SetClassAutoloading((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->SetErrmsgcallback((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->Setgvp((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->SetRTLD_NOW();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->SetRTLD_LAZY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->SetTempLevel((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->UnloadFile((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_Delete((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_Exec((CallFunc_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->CallFunc_ExecInt((CallFunc_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->CallFunc_ExecInt64((CallFunc_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TInterpreter*) G__getstructoffset())->CallFunc_ExecDouble((CallFunc_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->CallFunc_Factory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->CallFunc_FactoryCopy((CallFunc_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->CallFunc_FactoryMethod((CallFunc_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_Init((CallFunc_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->CallFunc_IsValid((CallFunc_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_ResetArg((CallFunc_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetArg((CallFunc_t*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetArg((CallFunc_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetArg((CallFunc_t*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetArg((CallFunc_t*) G__int(libp->para[0]), (ULong64_t) G__ULonglong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetArgArray((CallFunc_t*) G__int(libp->para[0]), (Long_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetArgs((CallFunc_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetFunc((CallFunc_t*) G__int(libp->para[0]), (ClassInfo_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Long_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetFunc((CallFunc_t*) G__int(libp->para[0]), (MethodInfo_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->CallFunc_SetFuncProto((CallFunc_t*) G__int(libp->para[0]), (ClassInfo_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Long_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_ClassProperty((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->ClassInfo_Delete((ClassInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->ClassInfo_Delete((ClassInfo_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->ClassInfo_DeleteArray((ClassInfo_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->ClassInfo_Destruct((ClassInfo_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Factory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Factory((G__value*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Factory((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Factory((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_GetMethodNArg((ClassInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_HasDefaultConstructor((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_HasMethod((ClassInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->ClassInfo_Init((ClassInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->ClassInfo_Init((ClassInfo_t*) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_IsBase((ClassInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_IsEnum((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_IsLoaded((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_IsValid((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_IsValidMethod((ClassInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_t*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Next((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_New((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_New((ClassInfo_t*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_New((ClassInfo_t*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_New((ClassInfo_t*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Property((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_RootFlag((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Size((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Tagnum((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_FileName((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_FullName((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Name((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_Title((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->ClassInfo_TmpltName((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Delete((BaseClassInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Factory((ClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Next((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Next((BaseClassInfo_t*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Offset((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Property((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Tagnum((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_FullName((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_Name((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->BaseClassInfo_TmpltName((BaseClassInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_ArrayDim((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Delete((DataMemberInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Factory((ClassInfo_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Factory());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_FactoryCopy((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_IsValid((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_MaxIndex((DataMemberInfo_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Next((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Offset((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Property((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_TypeProperty((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_TypeSize((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_TypeName((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_TypeTrueName((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Name((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_Title((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->DataMemberInfo_ValidArrayIndex((DataMemberInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->MethodInfo_CreateSignature((MethodInfo_t*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->MethodInfo_Delete((MethodInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_Factory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_FactoryCopy((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_InterfaceMethod((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_IsValid((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_NArg((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_NDefaultArg((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_Next((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_Property((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_Type((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_GetMangledName((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_GetPrototype((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_Name((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_TypeName((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodInfo_Title((MethodInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_Delete((MethodArgInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_Factory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_FactoryCopy((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_IsValid((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_Next((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_Property((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_DefaultValue((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_Name((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->MethodArgInfo_TypeName((MethodArgInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->TypeInfo_Delete((TypeInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_Factory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_Factory((G__value*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_FactoryCopy((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->TypeInfo_Init((TypeInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_IsValid((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_Name((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_Property((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_RefType((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_Size((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->TypeInfo_TrueName((TypeInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Delete((TypedefInfo_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Factory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_FactoryCopy((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Init((TypedefInfo_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_IsValid((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Property((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Size((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_TrueName((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Name((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TInterpreter*) G__getstructoffset())->TypedefInfo_Title((TypedefInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_213(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TInterpreter*& obj = TInterpreter::Instance();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TInterpreter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TInterpreter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_216(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TInterpreter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TInterpreter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_221(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInterpreter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TInterpreter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TInterpreter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TInterpreter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_160_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TInterpreter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TInterpreter G__TTInterpreter;
static int G__G__Meta_160_0_226(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[] (TInterpreter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TInterpreter*) (soff+(sizeof(TInterpreter)*i)))->~G__TTInterpreter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TInterpreter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TInterpreter*) (soff))->~G__TTInterpreter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Meta_160_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TInterpreter* dest = (TInterpreter*) G__getstructoffset();
   *dest = *(TInterpreter*) libp->para[0].ref;
   const TInterpreter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TIsAProxy */
static int G__G__Meta_162_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TIsAProxy* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TIsAProxy(*(type_info*) libp->para[0].ref, (void*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TIsAProxy(*(type_info*) libp->para[0].ref, (void*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TIsAProxy(*(type_info*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TIsAProxy(*(type_info*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TIsAProxy G__TTIsAProxy;
static int G__G__Meta_162_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[] (TIsAProxy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TIsAProxy*) (soff+(sizeof(TIsAProxy)*i)))->~G__TTIsAProxy();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TIsAProxy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TIsAProxy*) (soff))->~G__TTIsAProxy();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMethodArg */
static int G__G__Meta_163_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMethodArg* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMethodArg((MethodArgInfo_t*) G__int(libp->para[0]), (TFunction*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMethodArg((MethodArgInfo_t*) G__int(libp->para[0]), (TFunction*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMethodArg((MethodArgInfo_t*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMethodArg((MethodArgInfo_t*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMethodArg[n];
       } else {
         p = new((void*) gvp) TMethodArg[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMethodArg;
       } else {
         p = new((void*) gvp) TMethodArg;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TMethodArg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMethodArg*) G__getstructoffset())->GetDefault());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMethodArg*) G__getstructoffset())->GetMethod());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMethodArg*) G__getstructoffset())->GetTypeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMethodArg*) G__getstructoffset())->GetFullTypeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMethodArg*) G__getstructoffset())->GetDataMember());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMethodArg*) G__getstructoffset())->GetOptions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMethodArg::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMethodArg::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMethodArg::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMethodArg::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMethodArg*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMethodArg::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMethodArg::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMethodArg::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_163_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMethodArg::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMethodArg G__TTMethodArg;
static int G__G__Meta_163_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[] (TMethodArg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMethodArg*) (soff+(sizeof(TMethodArg)*i)))->~G__TTMethodArg();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMethodArg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMethodArg*) (soff))->~G__TTMethodArg();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::TSchemaRule */
static int G__G__Meta_168_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::TSchemaRule* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::TSchemaRule[n];
     } else {
       p = new((void*) gvp) ROOT::TSchemaRule[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::TSchemaRule;
     } else {
       p = new((void*) gvp) ROOT::TSchemaRule;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::TSchemaRule* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::TSchemaRule(*(ROOT::TSchemaRule*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) ROOT::TSchemaRule(*(ROOT::TSchemaRule*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::TSchemaRule& obj = ((ROOT::TSchemaRule*) G__getstructoffset())->operator=(*(ROOT::TSchemaRule*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::TSchemaRule*) G__getstructoffset())->operator==(*(ROOT::TSchemaRule*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::TSchemaRule*) G__getstructoffset())->SetFromRule((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::TSchemaRule*) G__getstructoffset())->SetVersion(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->TestVersion((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::TSchemaRule*) G__getstructoffset())->SetChecksum(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->TestChecksum((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetSourceClass(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetSourceClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetTargetClass(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetTargetClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetTarget(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetTargetString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetSource(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetSource());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetEmbed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetEmbed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->IsAliasRule());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->IsRenameRule());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetCode(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetAttributes(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetAttributes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->HasTarget(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->HasSource(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetReadFunctionPointer((ROOT::TSchemaRule::ReadFuncPtr_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetReadFunctionPointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetReadRawFunctionPointer((ROOT::TSchemaRule::ReadRawFuncPtr_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetReadRawFunctionPointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetInclude(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetInclude());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->SetRuleType((ROOT::TSchemaRule::RuleType_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->GetRuleType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaRule*) G__getstructoffset())->Conflicts((ROOT::TSchemaRule*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const ROOT::TSchemaRule*) G__getstructoffset())->AsString(*(TString*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const ROOT::TSchemaRule*) G__getstructoffset())->AsString(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ROOT::TSchemaRule::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaRule::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ROOT::TSchemaRule::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::TSchemaRule::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaRule::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ROOT::TSchemaRule::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaRule::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_168_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ROOT::TSchemaRule::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::TSchemaRule G__TROOTcLcLTSchemaRule;
static int G__G__Meta_168_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::TSchemaRule*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::TSchemaRule*) (soff+(sizeof(ROOT::TSchemaRule)*i)))->~G__TROOTcLcLTSchemaRule();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::TSchemaRule*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::TSchemaRule*) (soff))->~G__TROOTcLcLTSchemaRule();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::TSchemaRule::TSources */
static int G__G__Meta_169_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::TSchemaRule::TSources* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::TSchemaRule::TSources(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) ROOT::TSchemaRule::TSources(
(const char*) G__int(libp->para[0]), (const char*) 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 ROOT::TSchemaRule::TSources((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) ROOT::TSchemaRule::TSources((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::TSchemaRule::TSources((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) ROOT::TSchemaRule::TSources((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new ROOT::TSchemaRule::TSources[n];
       } else {
         p = new((void*) gvp) ROOT::TSchemaRule::TSources[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new ROOT::TSchemaRule::TSources;
       } else {
         p = new((void*) gvp) ROOT::TSchemaRule::TSources;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((ROOT::TSchemaRule::TSources*) G__getstructoffset())->GetDimensions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ROOT::TSchemaRule::TSources::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaRule::TSources::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ROOT::TSchemaRule::TSources::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::TSchemaRule::TSources::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaRule::TSources*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaRule::TSources::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ROOT::TSchemaRule::TSources::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaRule::TSources::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_169_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ROOT::TSchemaRule::TSources::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Meta_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ROOT::TSchemaRule::TSources* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ROOT::TSchemaRule::TSources(*(ROOT::TSchemaRule::TSources*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::TSchemaRule::TSources G__TROOTcLcLTSchemaRulecLcLTSources;
static int G__G__Meta_169_0_16(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[] (ROOT::TSchemaRule::TSources*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::TSchemaRule::TSources*) (soff+(sizeof(ROOT::TSchemaRule::TSources)*i)))->~G__TROOTcLcLTSchemaRulecLcLTSources();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::TSchemaRule::TSources*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::TSchemaRule::TSources*) (soff))->~G__TROOTcLcLTSchemaRulecLcLTSources();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Meta_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::TSchemaRule::TSources* dest = (ROOT::TSchemaRule::TSources*) G__getstructoffset();
   *dest = *(ROOT::TSchemaRule::TSources*) libp->para[0].ref;
   const ROOT::TSchemaRule::TSources& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<pair<int,int>,allocator<pair<int,int> > > */
static int G__G__Meta_173_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<int,int>& obj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->at((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<pair<int,int>,allocator<pair<int,int> > >::iterator* pobj;
         vector<pair<int,int>,allocator<pair<int,int> > >::iterator xobj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->begin();
         pobj = new vector<pair<int,int>,allocator<pair<int,int> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<pair<int,int>,allocator<pair<int,int> > >::iterator* pobj;
         vector<pair<int,int>,allocator<pair<int,int> > >::iterator xobj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->end();
         pobj = new vector<pair<int,int>,allocator<pair<int,int> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator* pobj;
         vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator xobj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->rbegin();
         pobj = new vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator* pobj;
         vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator xobj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->rend();
         pobj = new vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->resize((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->resize((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]), *((pair<int,int>*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<int,int>& obj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->operator[]((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<pair<int,int>,allocator<pair<int,int> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<pair<int,int>,allocator<pair<int,int> > >[n];
     } else {
       p = new((void*) gvp) vector<pair<int,int>,allocator<pair<int,int> > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<pair<int,int>,allocator<pair<int,int> > >;
     } else {
       p = new((void*) gvp) vector<pair<int,int>,allocator<pair<int,int> > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<pair<int,int>,allocator<pair<int,int> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<pair<int,int>,allocator<pair<int,int> > >((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]), *(pair<int,int>*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<pair<int,int>,allocator<pair<int,int> > >((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]), *(pair<int,int>*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<pair<int,int>,allocator<pair<int,int> > >((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<pair<int,int>,allocator<pair<int,int> > >((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<pair<int,int>,allocator<pair<int,int> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<pair<int,int>,allocator<pair<int,int> > >(*(vector<pair<int,int>,allocator<pair<int,int> > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<pair<int,int>,allocator<pair<int,int> > >(*(vector<pair<int,int>,allocator<pair<int,int> > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<pair<int,int>,allocator<pair<int,int> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<pair<int,int>,allocator<pair<int,int> > >(*((vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator*) G__int(libp->para[0])), *((vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<pair<int,int>,allocator<pair<int,int> > >(*((vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator*) G__int(libp->para[0])), *((vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<pair<int,int>,allocator<pair<int,int> > >& obj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->operator=(*(vector<pair<int,int>,allocator<pair<int,int> > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->reserve((vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<int,int>& obj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<int,int>& obj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->push_back(*(pair<int,int>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->swap(*(vector<pair<int,int>,allocator<pair<int,int> > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<pair<int,int>,allocator<pair<int,int> > >::iterator* pobj;
         vector<pair<int,int>,allocator<pair<int,int> > >::iterator xobj = ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->insert(*((vector<pair<int,int>,allocator<pair<int,int> > >::iterator*) G__int(libp->para[0])), *(pair<int,int>*) libp->para[1].ref);
         pobj = new vector<pair<int,int>,allocator<pair<int,int> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->insert(*((vector<pair<int,int>,allocator<pair<int,int> > >::iterator*) G__int(libp->para[0])), *((vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator*) G__int(libp->para[1]))
, *((vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->insert(*((vector<pair<int,int>,allocator<pair<int,int> > >::iterator*) G__int(libp->para[0])), (vector<pair<int,int>,allocator<pair<int,int> > >::size_type) G__int(libp->para[1])
, *(pair<int,int>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->erase(*((vector<pair<int,int>,allocator<pair<int,int> > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->erase(*((vector<pair<int,int>,allocator<pair<int,int> > >::iterator*) G__int(libp->para[0])), *((vector<pair<int,int>,allocator<pair<int,int> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_173_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<pair<int,int>,allocator<pair<int,int> > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<pair<int,int>,allocator<pair<int,int> > > G__TvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR;
static int G__G__Meta_173_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<pair<int,int>,allocator<pair<int,int> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<pair<int,int>,allocator<pair<int,int> > >*) (soff+(sizeof(vector<pair<int,int>,allocator<pair<int,int> > >)*i)))->~G__TvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<pair<int,int>,allocator<pair<int,int> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<pair<int,int>,allocator<pair<int,int> > >*) (soff))->~G__TvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::TSchemaMatch */
static int G__G__Meta_180_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaMatch*) G__getstructoffset())->GetRuleWithSource(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ROOT::TSchemaMatch*) G__getstructoffset())->GetRuleWithTarget(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaMatch*) G__getstructoffset())->HasRuleWithSource(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::TSchemaMatch*) G__getstructoffset())->HasRuleWithTarget(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ROOT::TSchemaMatch::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaMatch::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ROOT::TSchemaMatch::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::TSchemaMatch::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::TSchemaMatch*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaMatch::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ROOT::TSchemaMatch::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ROOT::TSchemaMatch::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_180_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ROOT::TSchemaMatch::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::TSchemaMatch G__TROOTcLcLTSchemaMatch;
static int G__G__Meta_180_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[] (ROOT::TSchemaMatch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::TSchemaMatch*) (soff+(sizeof(ROOT::TSchemaMatch)*i)))->~G__TROOTcLcLTSchemaMatch();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::TSchemaMatch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::TSchemaMatch*) (soff))->~G__TROOTcLcLTSchemaMatch();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerBasicType */
static int G__G__Meta_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerBasicType* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerBasicType[n];
     } else {
       p = new((void*) gvp) TStreamerBasicType[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerBasicType;
     } else {
       p = new((void*) gvp) TStreamerBasicType;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerBasicType* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerBasicType(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TStreamerBasicType(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerBasicType*) G__getstructoffset())->GetCounter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerBasicType::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBasicType::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerBasicType::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerBasicType::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBasicType*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBasicType::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerBasicType::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBasicType::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_182_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerBasicType::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerBasicType G__TTStreamerBasicType;
static int G__G__Meta_182_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[] (TStreamerBasicType*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerBasicType*) (soff+(sizeof(TStreamerBasicType)*i)))->~G__TTStreamerBasicType();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerBasicType*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerBasicType*) (soff))->~G__TTStreamerBasicType();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerBase */
static int G__G__Meta_185_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerBase* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerBase[n];
     } else {
       p = new((void*) gvp) TStreamerBase[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerBase;
     } else {
       p = new((void*) gvp) TStreamerBase;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerBase* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerBase(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TStreamerBase(
(const char*) G__int(libp->para[0]), (const char*) 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__MetaLN_TStreamerBase));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerBase*) G__getstructoffset())->GetBaseVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TStreamerBase*) G__getstructoffset())->GetNewBaseClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerBase*) G__getstructoffset())->ReadBuffer(*(TBuffer*) libp->para[0].ref, (char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBase*) G__getstructoffset())->SetNewBaseClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBase*) G__getstructoffset())->SetBaseVersion((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStreamerBase*) G__getstructoffset())->WriteBuffer(*(TBuffer*) libp->para[0].ref, (char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_185_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerBase G__TTStreamerBase;
static int G__G__Meta_185_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStreamerBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerBase*) (soff+(sizeof(TStreamerBase)*i)))->~G__TTStreamerBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerBase*) (soff))->~G__TTStreamerBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerBasicPointer */
static int G__G__Meta_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerBasicPointer* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerBasicPointer[n];
     } else {
       p = new((void*) gvp) TStreamerBasicPointer[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerBasicPointer;
     } else {
       p = new((void*) gvp) TStreamerBasicPointer;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerBasicPointer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerBasicPointer(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TStreamerBasicPointer(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStreamerBasicPointer*) G__getstructoffset())->GetCountClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStreamerBasicPointer*) G__getstructoffset())->GetCountName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerBasicPointer*) G__getstructoffset())->GetCountVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBasicPointer*) G__getstructoffset())->SetCountClass((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBasicPointer*) G__getstructoffset())->SetCountName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBasicPointer*) G__getstructoffset())->SetCountVersion((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerBasicPointer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBasicPointer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerBasicPointer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerBasicPointer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerBasicPointer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBasicPointer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerBasicPointer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerBasicPointer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_186_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerBasicPointer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerBasicPointer G__TTStreamerBasicPointer;
static int G__G__Meta_186_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStreamerBasicPointer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerBasicPointer*) (soff+(sizeof(TStreamerBasicPointer)*i)))->~G__TTStreamerBasicPointer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerBasicPointer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerBasicPointer*) (soff))->~G__TTStreamerBasicPointer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerLoop */
static int G__G__Meta_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerLoop* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerLoop[n];
     } else {
       p = new((void*) gvp) TStreamerLoop[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerLoop;
     } else {
       p = new((void*) gvp) TStreamerLoop;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerLoop* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerLoop(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TStreamerLoop(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStreamerLoop*) G__getstructoffset())->GetCountClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStreamerLoop*) G__getstructoffset())->GetCountName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerLoop*) G__getstructoffset())->GetCountVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerLoop*) G__getstructoffset())->SetCountClass((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerLoop*) G__getstructoffset())->SetCountName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerLoop*) G__getstructoffset())->SetCountVersion((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerLoop::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerLoop::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerLoop::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerLoop::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerLoop*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerLoop::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerLoop::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerLoop::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_187_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerLoop::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerLoop G__TTStreamerLoop;
static int G__G__Meta_187_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStreamerLoop*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerLoop*) (soff+(sizeof(TStreamerLoop)*i)))->~G__TTStreamerLoop();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerLoop*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerLoop*) (soff))->~G__TTStreamerLoop();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerObject */
static int G__G__Meta_188_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObject[n];
     } else {
       p = new((void*) gvp) TStreamerObject[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObject;
     } else {
       p = new((void*) gvp) TStreamerObject;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerObject(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TStreamerObject(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_188_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerObject G__TTStreamerObject;
static int G__G__Meta_188_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[] (TStreamerObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerObject*) (soff+(sizeof(TStreamerObject)*i)))->~G__TTStreamerObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerObject*) (soff))->~G__TTStreamerObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerObjectAny */
static int G__G__Meta_189_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObjectAny* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObjectAny[n];
     } else {
       p = new((void*) gvp) TStreamerObjectAny[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObjectAny;
     } else {
       p = new((void*) gvp) TStreamerObjectAny;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObjectAny* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerObjectAny(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TStreamerObjectAny(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerObjectAny::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectAny::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerObjectAny::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerObjectAny::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerObjectAny*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectAny::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObjectAny::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectAny::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_189_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObjectAny::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerObjectAny G__TTStreamerObjectAny;
static int G__G__Meta_189_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[] (TStreamerObjectAny*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerObjectAny*) (soff+(sizeof(TStreamerObjectAny)*i)))->~G__TTStreamerObjectAny();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerObjectAny*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerObjectAny*) (soff))->~G__TTStreamerObjectAny();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerObjectPointer */
static int G__G__Meta_190_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObjectPointer* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObjectPointer[n];
     } else {
       p = new((void*) gvp) TStreamerObjectPointer[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObjectPointer;
     } else {
       p = new((void*) gvp) TStreamerObjectPointer;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObjectPointer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerObjectPointer(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TStreamerObjectPointer(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerObjectPointer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectPointer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerObjectPointer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerObjectPointer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerObjectPointer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectPointer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObjectPointer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectPointer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_190_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObjectPointer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerObjectPointer G__TTStreamerObjectPointer;
static int G__G__Meta_190_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[] (TStreamerObjectPointer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerObjectPointer*) (soff+(sizeof(TStreamerObjectPointer)*i)))->~G__TTStreamerObjectPointer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerObjectPointer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerObjectPointer*) (soff))->~G__TTStreamerObjectPointer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerObjectAnyPointer */
static int G__G__Meta_191_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObjectAnyPointer* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObjectAnyPointer[n];
     } else {
       p = new((void*) gvp) TStreamerObjectAnyPointer[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerObjectAnyPointer;
     } else {
       p = new((void*) gvp) TStreamerObjectAnyPointer;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerObjectAnyPointer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerObjectAnyPointer(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TStreamerObjectAnyPointer(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerObjectAnyPointer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectAnyPointer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerObjectAnyPointer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerObjectAnyPointer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerObjectAnyPointer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectAnyPointer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObjectAnyPointer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerObjectAnyPointer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_191_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerObjectAnyPointer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerObjectAnyPointer G__TTStreamerObjectAnyPointer;
static int G__G__Meta_191_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[] (TStreamerObjectAnyPointer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerObjectAnyPointer*) (soff+(sizeof(TStreamerObjectAnyPointer)*i)))->~G__TTStreamerObjectAnyPointer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerObjectAnyPointer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerObjectAnyPointer*) (soff))->~G__TTStreamerObjectAnyPointer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerString */
static int G__G__Meta_192_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerString* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerString[n];
     } else {
       p = new((void*) gvp) TStreamerString[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerString;
     } else {
       p = new((void*) gvp) TStreamerString;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerString(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TStreamerString(
(const char*) G__int(libp->para[0]), (const char*) 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__MetaLN_TStreamerString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerString::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerString::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerString::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerString::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerString*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerString::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerString::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerString::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_192_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerString::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerString G__TTStreamerString;
static int G__G__Meta_192_0_19(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[] (TStreamerString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerString*) (soff+(sizeof(TStreamerString)*i)))->~G__TTStreamerString();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerString*) (soff))->~G__TTStreamerString();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerSTL */
static int G__G__Meta_193_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerSTL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerSTL[n];
     } else {
       p = new((void*) gvp) TStreamerSTL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerSTL;
     } else {
       p = new((void*) gvp) TStreamerSTL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerSTL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerSTL(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TStreamerSTL(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerSTL*) G__getstructoffset())->GetSTLtype());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStreamerSTL*) G__getstructoffset())->GetCtype());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerSTL*) G__getstructoffset())->SetSTLtype((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerSTL*) G__getstructoffset())->SetCtype((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerSTL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerSTL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerSTL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerSTL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerSTL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerSTL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerSTL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerSTL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_193_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerSTL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerSTL G__TTStreamerSTL;
static int G__G__Meta_193_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStreamerSTL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerSTL*) (soff+(sizeof(TStreamerSTL)*i)))->~G__TTStreamerSTL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerSTL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerSTL*) (soff))->~G__TTStreamerSTL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerSTLstring */
static int G__G__Meta_195_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerSTLstring* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerSTLstring[n];
     } else {
       p = new((void*) gvp) TStreamerSTLstring[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStreamerSTLstring;
     } else {
       p = new((void*) gvp) TStreamerSTLstring;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerSTLstring* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerSTLstring(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TStreamerSTLstring(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerSTLstring::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerSTLstring::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerSTLstring::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerSTLstring::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerSTLstring*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerSTLstring::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerSTLstring::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerSTLstring::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_195_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerSTLstring::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerSTLstring G__TTStreamerSTLstring;
static int G__G__Meta_195_0_19(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[] (TStreamerSTLstring*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerSTLstring*) (soff+(sizeof(TStreamerSTLstring)*i)))->~G__TTStreamerSTLstring();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerSTLstring*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerSTLstring*) (soff))->~G__TTStreamerSTLstring();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStreamerArtificial */
static int G__G__Meta_196_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStreamerArtificial* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStreamerArtificial(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TStreamerArtificial(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerArtificial*) G__getstructoffset())->SetReadFunc((ROOT::TSchemaRule::ReadFuncPtr_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerArtificial*) G__getstructoffset())->SetReadRawFunc((ROOT::TSchemaRule::ReadRawFuncPtr_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TStreamerArtificial*) G__getstructoffset())->GetReadFunc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TStreamerArtificial*) G__getstructoffset())->GetReadRawFunc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStreamerArtificial::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerArtificial::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStreamerArtificial::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStreamerArtificial::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStreamerArtificial*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerArtificial::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerArtificial::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStreamerArtificial::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_196_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStreamerArtificial::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStreamerArtificial G__TTStreamerArtificial;
static int G__G__Meta_196_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[] (TStreamerArtificial*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStreamerArtificial*) (soff+(sizeof(TStreamerArtificial)*i)))->~G__TTStreamerArtificial();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStreamerArtificial*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStreamerArtificial*) (soff))->~G__TTStreamerArtificial();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TToggle */
static int G__G__Meta_197_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TToggle* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TToggle[n];
     } else {
       p = new((void*) gvp) TToggle[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TToggle;
     } else {
       p = new((void*) gvp) TToggle;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TToggle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->SetToggledObject((TObject*) G__int(libp->para[0]), (TMethod*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->SetToggledVariable(*(Int_t*) G__Intref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TToggle*) G__getstructoffset())->IsInitialized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TToggle*) G__getstructoffset())->GetState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->Toggle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->SetOnValue((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TToggle*) G__getstructoffset())->GetOnValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->SetOffValue((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TToggle*) G__getstructoffset())->GetOffValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TToggle*) G__getstructoffset())->GetValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->SetValue((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TToggle*) G__getstructoffset())->GetGetter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TToggle*) G__getstructoffset())->GetSetter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TToggle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TToggle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TToggle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TToggle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TToggle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TToggle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TToggle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_197_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TToggle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Meta_197_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TToggle* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TToggle(*(TToggle*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TToggle));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TToggle G__TTToggle;
static int G__G__Meta_197_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TToggle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TToggle*) (soff+(sizeof(TToggle)*i)))->~G__TTToggle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TToggle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TToggle*) (soff))->~G__TTToggle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Meta_197_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TToggle* dest = (TToggle*) G__getstructoffset();
   *dest = *(TToggle*) libp->para[0].ref;
   const TToggle& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TToggleGroup */
static int G__G__Meta_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TToggleGroup* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TToggleGroup[n];
     } else {
       p = new((void*) gvp) TToggleGroup[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TToggleGroup;
     } else {
       p = new((void*) gvp) TToggleGroup;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TToggleGroup* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TToggleGroup(*(TToggleGroup*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TToggleGroup(*(TToggleGroup*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TToggleGroup& obj = ((TToggleGroup*) G__getstructoffset())->operator=(*(TToggleGroup*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TToggleGroup*) G__getstructoffset())->GetTogglesCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TToggleGroup*) G__getstructoffset())->At((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggleGroup*) G__getstructoffset())->Remove((TToggle*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggleGroup*) G__getstructoffset())->Remove((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggleGroup*) G__getstructoffset())->DeleteAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TToggleGroup*) G__getstructoffset())->First());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TToggleGroup*) G__getstructoffset())->Last());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TToggleGroup*) G__getstructoffset())->IndexOf((TToggle*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TToggleGroup*) G__getstructoffset())->Add((TToggle*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TToggleGroup*) G__getstructoffset())->Add((TToggle*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TToggleGroup*) G__getstructoffset())->InsertAt((TToggle*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TToggleGroup*) G__getstructoffset())->InsertAt((TToggle*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggleGroup*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggleGroup*) G__getstructoffset())->Select((TToggle*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TToggleGroup::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TToggleGroup::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TToggleGroup::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TToggleGroup::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TToggleGroup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TToggleGroup::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TToggleGroup::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TToggleGroup::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Meta_201_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TToggleGroup::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TToggleGroup G__TTToggleGroup;
static int G__G__Meta_201_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TToggleGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TToggleGroup*) (soff+(sizeof(TToggleGroup)*i)))->~G__TTToggleGroup();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TToggleGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TToggleGroup*) (soff))->~G__TTToggleGroup();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TClass */

/* TClassStreamer */

/* TMemberStreamer */

/* TVirtualIsAProxy */

/* ROOT */

/* TMethod */

/* TVirtualStreamerInfo */

/* TStreamerElement */

/* TDictionary */

/* TBaseClass */

/* TDataMember */

/* TClassRef */

/* TRealData */

/* TMethodCall */

/* ROOT::TSchemaRuleSet */

/* TClassGenerator */

/* TClassMenuItem */

/* TDataType */

/* TFunction */

/* TGlobal */

/* TInterpreter */

/* TIsAProxy */

/* TMethodArg */

/* ROOT::TSchemaRule */

/* ROOT::TSchemaRule::TSources */

/* vector<pair<int,int>,allocator<pair<int,int> > > */

/* ROOT::TSchemaMatch */

/* TStreamerBasicType */

/* TStreamerBase */

/* TStreamerBasicPointer */

/* TStreamerLoop */

/* TStreamerObject */

/* TStreamerObjectAny */

/* TStreamerObjectPointer */

/* TStreamerObjectAnyPointer */

/* TStreamerString */

/* TStreamerSTL */

/* TStreamerSTLstring */

/* TStreamerArtificial */

/* TToggle */

/* TToggleGroup */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Meta {
 public:
  G__Sizep2memfuncG__Meta(): p(&G__Sizep2memfuncG__Meta::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Meta::*p)();
};

size_t G__get_sizep2memfuncG__Meta()
{
  G__Sizep2memfuncG__Meta 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__Meta() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TClass))) {
     TClass *G__Lderived;
     G__Lderived=(TClass*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TClass),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TClass),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TClass),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TNamed))) {
     TNamed *G__Lderived;
     G__Lderived=(TNamed*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TNamed),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TMethod))) {
     TMethod *G__Lderived;
     G__Lderived=(TMethod*)0x1000;
     {
       TFunction *G__Lpbase=(TFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethod),G__get_linked_tagnum(&G__G__MetaLN_TFunction),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethod),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethod),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethod),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo))) {
     TVirtualStreamerInfo *G__Lderived;
     G__Lderived=(TVirtualStreamerInfo*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement))) {
     TStreamerElement *G__Lderived;
     G__Lderived=(TStreamerElement*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TDictionary))) {
     TDictionary *G__Lderived;
     G__Lderived=(TDictionary*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDictionary),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDictionary),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TBaseClass))) {
     TBaseClass *G__Lderived;
     G__Lderived=(TBaseClass*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TBaseClass),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TBaseClass),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TBaseClass),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TDataMember))) {
     TDataMember *G__Lderived;
     G__Lderived=(TDataMember*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataMember),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataMember),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataMember),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TRealData))) {
     TRealData *G__Lderived;
     G__Lderived=(TRealData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TRealData),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TMethodCall))) {
     TMethodCall *G__Lderived;
     G__Lderived=(TMethodCall*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet))) {
     ROOT::TSchemaRuleSet *G__Lderived;
     G__Lderived=(ROOT::TSchemaRuleSet*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TClassGenerator))) {
     TClassGenerator *G__Lderived;
     G__Lderived=(TClassGenerator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassGenerator),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem))) {
     TClassMenuItem *G__Lderived;
     G__Lderived=(TClassMenuItem*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TDataType))) {
     TDataType *G__Lderived;
     G__Lderived=(TDataType*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataType),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataType),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataType),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TFunction))) {
     TFunction *G__Lderived;
     G__Lderived=(TFunction*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TFunction),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TFunction),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TFunction),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TGlobal))) {
     TGlobal *G__Lderived;
     G__Lderived=(TGlobal*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TGlobal),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TGlobal),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TGlobal),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TInterpreter))) {
     TInterpreter *G__Lderived;
     G__Lderived=(TInterpreter*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TInterpreter),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TInterpreter),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy))) {
     TIsAProxy *G__Lderived;
     G__Lderived=(TIsAProxy*)0x1000;
     {
       TVirtualIsAProxy *G__Lpbase=(TVirtualIsAProxy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy),G__get_linked_tagnum(&G__G__MetaLN_TVirtualIsAProxy),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TMethodArg))) {
     TMethodArg *G__Lderived;
     G__Lderived=(TMethodArg*)0x1000;
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodArg),G__get_linked_tagnum(&G__G__MetaLN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodArg),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodArg),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule))) {
     ROOT::TSchemaRule *G__Lderived;
     G__Lderived=(ROOT::TSchemaRule*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources))) {
     ROOT::TSchemaRule::TSources *G__Lderived;
     G__Lderived=(ROOT::TSchemaRule::TSources*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch))) {
     ROOT::TSchemaMatch *G__Lderived;
     G__Lderived=(ROOT::TSchemaMatch*)0x1000;
     {
       TObjArray *G__Lpbase=(TObjArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch),G__get_linked_tagnum(&G__G__MetaLN_TObjArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch),G__get_linked_tagnum(&G__G__MetaLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch),G__get_linked_tagnum(&G__G__MetaLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType))) {
     TStreamerBasicType *G__Lderived;
     G__Lderived=(TStreamerBasicType*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase))) {
     TStreamerBase *G__Lderived;
     G__Lderived=(TStreamerBase*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer))) {
     TStreamerBasicPointer *G__Lderived;
     G__Lderived=(TStreamerBasicPointer*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop))) {
     TStreamerLoop *G__Lderived;
     G__Lderived=(TStreamerLoop*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject))) {
     TStreamerObject *G__Lderived;
     G__Lderived=(TStreamerObject*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny))) {
     TStreamerObjectAny *G__Lderived;
     G__Lderived=(TStreamerObjectAny*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer))) {
     TStreamerObjectPointer *G__Lderived;
     G__Lderived=(TStreamerObjectPointer*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer))) {
     TStreamerObjectAnyPointer *G__Lderived;
     G__Lderived=(TStreamerObjectAnyPointer*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerString))) {
     TStreamerString *G__Lderived;
     G__Lderived=(TStreamerString*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerString),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerString),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerString),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL))) {
     TStreamerSTL *G__Lderived;
     G__Lderived=(TStreamerSTL*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring))) {
     TStreamerSTLstring *G__Lderived;
     G__Lderived=(TStreamerSTLstring*)0x1000;
     {
       TStreamerSTL *G__Lpbase=(TStreamerSTL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring),G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial))) {
     TStreamerArtificial *G__Lderived;
     G__Lderived=(TStreamerArtificial*)0x1000;
     {
       TStreamerElement *G__Lpbase=(TStreamerElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial),G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TToggle))) {
     TToggle *G__Lderived;
     G__Lderived=(TToggle*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggle),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggle),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup))) {
     TToggleGroup *G__Lderived;
     G__Lderived=(TToggleGroup*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup),G__get_linked_tagnum(&G__G__MetaLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup),G__get_linked_tagnum(&G__G__MetaLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Meta() {

   /* 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("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("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("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("ClassStreamerFunc_t",89,-1,0,-1);
   G__setnewtype(-1,"Streamer function for a class",0);
   G__search_typename2("MemberStreamerFunc_t",89,-1,0,-1);
   G__setnewtype(-1,"Streamer function for a data member",0);
   G__search_typename2("VoidFuncPtr_t",89,-1,0,-1);
   G__setnewtype(-1,"pointer to void function",0);
   G__search_typename2("ShowMembersFunc_t",89,-1,0,-1);
   G__setnewtype(-1,"void (*ShowMembersFunc_t)(void *obj, TMemberInspector &R__insp);",0);
   G__search_typename2("IsAGlobalFunc_t",89,-1,0,-1);
   G__setnewtype(-1,"TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);",0);
   G__search_typename2("NewFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__setnewtype(-1,"void *(*NewFunc_t)(void *);",0);
   G__search_typename2("NewArrFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__setnewtype(-1,"void *(*NewArrFunc_t)(Long_t size, void *arena);",0);
   G__search_typename2("DelFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__setnewtype(-1,"void  (*DelFunc_t)(void *);",0);
   G__search_typename2("DelArrFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__setnewtype(-1,"void  (*DelArrFunc_t)(void *);",0);
   G__search_typename2("DesFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__setnewtype(-1,"void  (*DesFunc_t)(void *);",0);
   G__search_typename2("DirAutoAdd_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__setnewtype(-1,"void  (*DirAutoAdd_t)(void *, TDirectory*);",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CallFunc_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ClassInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BaseClassInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DataMemberInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MethodInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MethodArgInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TypeInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TypedefInfo_t",121,-1,0,-1);
   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__MetaLN_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__MetaLN_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__MetaLN_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__MetaLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("StreamerImpl_t",97,-1,0,G__get_linked_tagnum(&G__G__MetaLN_TClass));
   G__setnewtype(-1,"void (TClass::*StreamerImpl_t)(void *obj, TBuffer &b, const TClass *onfile_class) const;",0);
   G__search_typename2("char *(*)(const char* prompt)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("void (*)(char* line)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("void (*)()",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RuleType_t",117,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t),0,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ReadFuncPtr_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   G__setnewtype(-1,"void (*ReadFuncPtr_t)( char*, TVirtualObject* );",0);
   G__search_typename2("ReadRawFuncPtr_t",89,-1,0,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   G__setnewtype(-1,"void (*ReadRawFuncPtr_t)( char*, TBuffer&);",0);
   G__search_typename2("pair<Int_t,Int_t>",117,G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Int_t,Int_t> >",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR),256,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR),1,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR),257,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<int,int> >",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TClass */
static void G__setup_memvarTClass(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TClass));
   { TClass *p; p=(TClass*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kClassSaved=%lldLL",(long long)TClass::kClassSaved).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIgnoreTObjectStreamer=%lldLL",(long long)TClass::kIgnoreTObjectStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kUnloaded=%lldLL",(long long)TClass::kUnloaded).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsTObject=%lldLL",(long long)TClass::kIsTObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsForeign=%lldLL",(long long)TClass::kIsForeign).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsEmulation=%lldLL",(long long)TClass::kIsEmulation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kStartWithTObject=%lldLL",(long long)TClass::kStartWithTObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWarned=%lldLL",(long long)TClass::kWarned).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kHasNameMapNode=%lldLL",(long long)TClass::kHasNameMapNode).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLENewType),-1,-2,1,G__FastAllocString(2048).Format("kRealNew=%lldLL",(long long)TClass::kRealNew).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLENewType),-1,-2,1,G__FastAllocString(2048).Format("kClassNew=%lldLL",(long long)TClass::kClassNew).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLENewType),-1,-2,1,G__FastAllocString(2048).Format("kDummyNew=%lldLL",(long long)TClass::kDummyNew).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fStreamerInfo=",0,"Array of TVirtualStreamerInfo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),G__defined_typename("map<std::string,TObjArray*>"),-1,4,"fConversionStreamerInfo=",0,"Array of the streamer infos derived from another class.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fRealData=",0,"linked list for persistent members including base classes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fBase=",0,"linked list for base classes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fData=",0,"linked list for data members");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fMethod=",0,"linked list for methods");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fAllPubData=",0,"all public data members (including from base classes)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fAllPubMethod=",0,"all public methods (including from base classes)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fClassMenuList=",0,"list of class menu items");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-1,4,"fDeclFileName=",0,"name of class declaration file");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-1,4,"fImplFileName=",0,"name of class implementation file");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,4,"fDeclFileLine=",0,"line of class declaration");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,4,"fImplFileLine=",0,"line of class implementation");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fInstanceCount=",0,"number of instances of this class");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fOnHeap=",0,"number of instances on heap");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCheckSum=",0,"checksum of data members and base classes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TVirtualCollectionProxy),-1,-1,4,"fCollectionProxy=",0,"Collection interface");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Version_t"),-1,4,"fClassVersion=",0,"Class version Identifier");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ClassInfo_t"),-1,4,"fClassInfo=",0,"pointer to CINT class info class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fContextMenuTitle=",0,"context menu title");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MetaLN_type_info),-1,-1,4,"fTypeInfo=",0,"pointer to the C++ type information.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ShowMembersFunc_t"),-1,4,"fShowMembers=",0,"pointer to the class's ShowMembers function");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fInterShowMembers=",0,"Interpreter call setup for ShowMembers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer),-1,-1,4,"fStreamer=",0,"pointer to streamer function");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fSharedLibs=",0,"shared libraries containing class code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TVirtualIsAProxy),-1,-1,4,"fIsA=",0,"!pointer to the class's IsA proxy.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("IsAGlobalFunc_t"),-1,4,"fGlobalIsA=",0,"pointer to a global IsA function.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,4,"fIsAMethod=",0,"!saved info to call a IsA member function");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("NewFunc_t"),-1,4,"fNew=",0,"pointer to a function newing one object.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("NewArrFunc_t"),-1,4,"fNewArray=",0,"pointer to a function newing an array of objects.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DelFunc_t"),-1,4,"fDelete=",0,"pointer to a function deleting one object.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DelArrFunc_t"),-1,4,"fDeleteArray=",0,"pointer to a function deleting an array of objects.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DesFunc_t"),-1,4,"fDestructor=",0,"pointer to a function call an object's destructor.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DirAutoAdd_t"),-1,4,"fDirAutoAdd=",0,"pointer which implements the Directory Auto Add feature for this class.']'");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ClassStreamerFunc_t"),-1,4,"fStreamerFunc=",0,"Wrapper around this class custom Streamer member function.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSizeof=",0,"Sizeof the class.");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fProperty=",0,"!Property");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVersionUsed=",0,"!Indicates whether GetClassVersion has been called");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsOffsetStreamerSet=",0,"!saved remember if fOffsetStreamer has been set.");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fOffsetStreamer=",0,"!saved info to call Streamer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStreamerType=",0,"!cached of the streaming method to use");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo),-1,-1,4,"fCurrentInfo=",0,"!cached current streamer info.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,4,"fRefStart=",0,"!List of references to this object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TVirtualRefProxy),-1,-1,4,"fRefProxy=",0,"!Pointer to reference proxy if this class represents a reference");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet),-1,-1,4,"fSchemaRules=",0,"! Schema evolution rules");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("StreamerImpl_t"),-1,4,"fStreamerImpl=",0,"! Pointer to the function implementing the right streaming behavior for the class represented by this object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTMapTypeToTClass),G__defined_typename("IdMap_t"),-2,4,"fgIdMap=",0,"Map from typeid to TClass pointer");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLENewType),-1,-2,4,"fgCallingNew=",0,"Intent of why/how TClass::New() is called");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgClassCount=",0,"provides unique id for a each class");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kLoading=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kDefault=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kEmulated=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kTObject=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kInstrumented=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kForeign=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLdA),-1,-2,4,"kExternal=16LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_THashTable),-1,-2,4,"fgClassTypedefHash=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_THashTable),-1,-2,4,"fgClassShortTypedefHash=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TClassStreamer */
static void G__setup_memvarTClassStreamer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer));
   { TClassStreamer *p; p=(TClassStreamer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ClassStreamerFunc_t"),-1,4,"fStreamer=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,2,"fOnFileClass=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMemberStreamer */
static void G__setup_memvarTMemberStreamer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer));
   { TMemberStreamer *p; p=(TMemberStreamer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("MemberStreamerFunc_t"),-1,4,"fStreamer=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,4,"fOnFileClass=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualIsAProxy */
static void G__setup_memvarTVirtualIsAProxy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TVirtualIsAProxy));
   { TVirtualIsAProxy *p; p=(TVirtualIsAProxy*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT */
static void G__setup_memvarROOT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   {
   }
   G__tag_memvar_reset();
}


   /* TMethod */
static void G__setup_memvarTMethod(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethod));
   { TMethod *p; p=(TMethod*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fClass=",0,"pointer to the class");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MetaLN_EMenuItemKind),-1,-1,4,"fMenuItem=",0,"type of menuitem in context menu");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fGetter=",0,"state getter in case this is a *TOGGLE method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,4,"fGetterMethod=",0,"methodcall for state getter in case this is a *TOGGLE method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,4,"fSetterMethod=",0,"methodcall for state setter in case this is a *TOGGLE method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualStreamerInfo */
static void G__setup_memvarTVirtualStreamerInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo));
   { TVirtualStreamerInfo *p; p=(TVirtualStreamerInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOptimized=",0,"! true if the Streamer has been optimized");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsBuilt=",0,"! true if the StreamerInfo has been 'built'");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgCanDelete=",0,"True if ReadBuffer can delete object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgOptimize=",0,"True if optimization on");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgStreamMemberWise=",0,"True if the collections are to be stream \"member-wise\" (when possible).");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo),-1,-2,2,"fgInfoFactory=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCannotOptimize=%lldLL",(long long)TVirtualStreamerInfo::kCannotOptimize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIgnoreTObjectStreamer=%lldLL",(long long)TVirtualStreamerInfo::kIgnoreTObjectStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kRecovered=%lldLL",(long long)TVirtualStreamerInfo::kRecovered).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNeedCheck=%lldLL",(long long)TVirtualStreamerInfo::kNeedCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsCompiled=%lldLL",(long long)TVirtualStreamerInfo::kIsCompiled).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kBase=%lldLL",(long long)TVirtualStreamerInfo::kBase).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kOffsetL=%lldLL",(long long)TVirtualStreamerInfo::kOffsetL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kOffsetP=%lldLL",(long long)TVirtualStreamerInfo::kOffsetP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCounter=%lldLL",(long long)TVirtualStreamerInfo::kCounter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCharStar=%lldLL",(long long)TVirtualStreamerInfo::kCharStar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kChar=%lldLL",(long long)TVirtualStreamerInfo::kChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kShort=%lldLL",(long long)TVirtualStreamerInfo::kShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kInt=%lldLL",(long long)TVirtualStreamerInfo::kInt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kLong=%lldLL",(long long)TVirtualStreamerInfo::kLong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kFloat=%lldLL",(long long)TVirtualStreamerInfo::kFloat).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kDouble=%lldLL",(long long)TVirtualStreamerInfo::kDouble).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kDouble32=%lldLL",(long long)TVirtualStreamerInfo::kDouble32).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kUChar=%lldLL",(long long)TVirtualStreamerInfo::kUChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kUShort=%lldLL",(long long)TVirtualStreamerInfo::kUShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kUInt=%lldLL",(long long)TVirtualStreamerInfo::kUInt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kULong=%lldLL",(long long)TVirtualStreamerInfo::kULong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kBits=%lldLL",(long long)TVirtualStreamerInfo::kBits).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kLong64=%lldLL",(long long)TVirtualStreamerInfo::kLong64).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kULong64=%lldLL",(long long)TVirtualStreamerInfo::kULong64).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kBool=%lldLL",(long long)TVirtualStreamerInfo::kBool).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kFloat16=%lldLL",(long long)TVirtualStreamerInfo::kFloat16).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kObject=%lldLL",(long long)TVirtualStreamerInfo::kObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAny=%lldLL",(long long)TVirtualStreamerInfo::kAny).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kObjectp=%lldLL",(long long)TVirtualStreamerInfo::kObjectp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kObjectP=%lldLL",(long long)TVirtualStreamerInfo::kObjectP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kTString=%lldLL",(long long)TVirtualStreamerInfo::kTString).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kTObject=%lldLL",(long long)TVirtualStreamerInfo::kTObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kTNamed=%lldLL",(long long)TVirtualStreamerInfo::kTNamed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAnyp=%lldLL",(long long)TVirtualStreamerInfo::kAnyp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAnyP=%lldLL",(long long)TVirtualStreamerInfo::kAnyP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kAnyPnoVT=%lldLL",(long long)TVirtualStreamerInfo::kAnyPnoVT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSTLp=%lldLL",(long long)TVirtualStreamerInfo::kSTLp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSkip=%lldLL",(long long)TVirtualStreamerInfo::kSkip).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSkipL=%lldLL",(long long)TVirtualStreamerInfo::kSkipL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSkipP=%lldLL",(long long)TVirtualStreamerInfo::kSkipP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kConv=%lldLL",(long long)TVirtualStreamerInfo::kConv).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kConvL=%lldLL",(long long)TVirtualStreamerInfo::kConvL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kConvP=%lldLL",(long long)TVirtualStreamerInfo::kConvP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSTL=%lldLL",(long long)TVirtualStreamerInfo::kSTL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kSTLstring=%lldLL",(long long)TVirtualStreamerInfo::kSTLstring).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kStreamer=%lldLL",(long long)TVirtualStreamerInfo::kStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kStreamLoop=%lldLL",(long long)TVirtualStreamerInfo::kStreamLoop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCache=%lldLL",(long long)TVirtualStreamerInfo::kCache).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kArtificial=%lldLL",(long long)TVirtualStreamerInfo::kArtificial).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCacheNew=%lldLL",(long long)TVirtualStreamerInfo::kCacheNew).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kCacheDelete=%lldLL",(long long)TVirtualStreamerInfo::kCacheDelete).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite),-1,-2,1,G__FastAllocString(2048).Format("kMissing=%lldLL",(long long)TVirtualStreamerInfo::kMissing).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerElement */
static void G__setup_memvarTStreamerElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement));
   { TStreamerElement *p; p=(TStreamerElement*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"element type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"sizeof element");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fArrayLength=",0,"cumulative size of all array dims");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fArrayDim=",0,"number of array dimensions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxIndex[5]=",0,"Maximum array index for array dimension \"dim\"");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOffset=",0,"!element offset in class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTObjectOffset=",0,"!base offset for TObject if the element inherits from it");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNewType=",0,"!new element type when reading");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fTypeName=",0,"Data type name of data member");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,2,"fClassObject=",0,"!pointer to class of object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,2,"fNewClass=",0,"!new element class when reading");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer),-1,-1,2,"fStreamer=",0,"!pointer to element Streamer");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"!Minimum of data member if a range is specified  [xmin,xmax,nbits]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"!Maximum of data member if a range is specified  [xmin,xmax,nbits]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFactor=",0,"!Conversion factor if a range is specified fFactor = (1<<nbits/(xmax-xmin)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTL=%lldLL",(long long)TStreamerElement::kSTL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLstring=%lldLL",(long long)TStreamerElement::kSTLstring).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLvector=%lldLL",(long long)TStreamerElement::kSTLvector).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLlist=%lldLL",(long long)TStreamerElement::kSTLlist).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLdeque=%lldLL",(long long)TStreamerElement::kSTLdeque).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLmap=%lldLL",(long long)TStreamerElement::kSTLmap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLset=%lldLL",(long long)TStreamerElement::kSTLset).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLmultimap=%lldLL",(long long)TStreamerElement::kSTLmultimap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLmultiset=%lldLL",(long long)TStreamerElement::kSTLmultiset).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLESTLtype),-1,-2,1,G__FastAllocString(2048).Format("kSTLbitset=%lldLL",(long long)TStreamerElement::kSTLbitset).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kHasRange=%lldLL",(long long)TStreamerElement::kHasRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCache=%lldLL",(long long)TStreamerElement::kCache).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kRepeat=%lldLL",(long long)TStreamerElement::kRepeat).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TStreamerElement::kRead).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TStreamerElement::kWrite).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDoNotDelete=%lldLL",(long long)TStreamerElement::kDoNotDelete).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDictionary */
static void G__setup_memvarTDictionary(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TDictionary));
   { TDictionary *p; p=(TDictionary*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TDictionary::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kVector=%lldLL",(long long)TDictionary::kVector).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kList=%lldLL",(long long)TDictionary::kList).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kDeque=%lldLL",(long long)TDictionary::kDeque).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kMap=%lldLL",(long long)TDictionary::kMap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kMultimap=%lldLL",(long long)TDictionary::kMultimap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kSet=%lldLL",(long long)TDictionary::kSet).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDictionarycLcLESTLType),-1,-2,1,G__FastAllocString(2048).Format("kMultiset=%lldLL",(long long)TDictionary::kMultiset).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBaseClass */
static void G__setup_memvarTBaseClass(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TBaseClass));
   { TBaseClass *p; p=(TBaseClass*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("BaseClassInfo_t"),-1,4,"fInfo=",0,"pointer to CINT base class info");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,4,"fClassPtr=",0,"pointer to the base class TClass");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fClass=",0,"pointer to parent class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDataMember */
static void G__setup_memvarTDataMember(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataMember));
   { TDataMember *p; p=(TDataMember*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TDataMembercLcLdA),-1,-2,4,"kObjIsPersistent=4LL",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DataMemberInfo_t"),-1,4,"fInfo=",0,"pointer to CINT data member info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fClass=",0,"pointer to the class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TDataType),-1,-1,4,"fDataType=",0,"pointer to data basic type descriptor");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fOffset=",0,"offset ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSTLCont=",0,"STL type ");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fProperty=",0,"Property");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fTypeName=",0,"data member type, e,g.: \"class TDirectory*\" -> \"TDirectory\".");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fFullTypeName=",0,"full type description of data member, e,g.: \"class TDirectory*\".");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fTrueTypeName=",0,"full type description with no typedef");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,4,"fValueGetter=",0,"method that returns a value;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,4,"fValueSetter=",0,"method which sets value;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fOptions=",0,"list of possible values 0=no restrictions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TClassRef */
static void G__setup_memvarTClassRef(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassRef));
   { TClassRef *p; p=(TClassRef*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_string),-1,-1,4,"fClassName=",0,"Name of referenced class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fClassPtr=",0,"! Ptr to the TClass object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,4,"fPrevious=",0,"! link to the previous refs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,4,"fNext=",0,"! link to the next refs ");
   }
   G__tag_memvar_reset();
}


   /* TRealData */
static void G__setup_memvarTRealData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TRealData));
   { TRealData *p; p=(TRealData*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TDataMember),-1,-1,4,"fDataMember=",0,"pointer to data member descriptor");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fThisOffset=",0,"offset with the THIS object pointer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fName=",0,"Concatenated names of this realdata");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer),-1,-1,4,"fStreamer=",0,"Object to stream the data member.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsObject=",0,"true if member is an object");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TRealDatacLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTransient=%lldLL",(long long)TRealData::kTransient).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMethodCall */
static void G__setup_memvarTMethodCall(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodCall));
   { TMethodCall *p; p=(TMethodCall*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType),-1,-2,1,G__FastAllocString(2048).Format("kLong=%lldLL",(long long)TMethodCall::kLong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType),-1,-2,1,G__FastAllocString(2048).Format("kDouble=%lldLL",(long long)TMethodCall::kDouble).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType),-1,-2,1,G__FastAllocString(2048).Format("kString=%lldLL",(long long)TMethodCall::kString).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType),-1,-2,1,G__FastAllocString(2048).Format("kOther=%lldLL",(long long)TMethodCall::kOther).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TMethodCall::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,4,"fFunc=",0,"CINT method invocation environment");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fOffset=",0,"offset added to object pointer before method invocation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fClass=",0,"pointer to the class info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TFunction),-1,-1,4,"fMetPtr=",0,"pointer to the method or function info");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fMethod=",0,"method name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fParams=",0,"argument string");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fProto=",0,"prototype string");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDtorOnly=",0,"call only dtor and not delete when calling ~xxx");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType),-1,-1,4,"fRetType=",0,"method return type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::TSchemaRuleSet */
static void G__setup_memvarROOTcLcLTSchemaRuleSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet));
   { ROOT::TSchemaRuleSet *p; p=(ROOT::TSchemaRuleSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSetcLcLEConsistencyCheck),-1,-2,1,G__FastAllocString(2048).Format("kNoCheck=%lldLL",(long long)ROOT::TSchemaRuleSet::kNoCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSetcLcLEConsistencyCheck),-1,-2,1,G__FastAllocString(2048).Format("kCheckAll=%lldLL",(long long)ROOT::TSchemaRuleSet::kCheckAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSetcLcLEConsistencyCheck),-1,-2,1,G__FastAllocString(2048).Format("kCheckConflict=%lldLL",(long long)ROOT::TSchemaRuleSet::kCheckConflict).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fPersistentRules=",0,"Array of the rules that will be embeded in the file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fRemainingRules=",0,"! Array of non-persisten rules - just for cleanup purposes - owns the elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fAllRules=",0,"! Array of all rules");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassRef),-1,-1,4,"fClass=",0,"! Target class pointer (for consistency checking)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fClassName=",0,"Target class name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVersion=",0,"Target class version");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCheckSum=",0,"Target class checksum");
   }
   G__tag_memvar_reset();
}


   /* TClassGenerator */
static void G__setup_memvarTClassGenerator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassGenerator));
   { TClassGenerator *p; p=(TClassGenerator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TClassMenuItem */
static void G__setup_memvarTClassMenuItem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem));
   { TClassMenuItem *p; p=(TClassMenuItem*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType),-1,-2,1,G__FastAllocString(2048).Format("kPopupUserFunction=%lldLL",(long long)TClassMenuItem::kPopupUserFunction).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType),-1,-2,1,G__FastAllocString(2048).Format("kPopupSeparator=%lldLL",(long long)TClassMenuItem::kPopupSeparator).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType),-1,-2,1,G__FastAllocString(2048).Format("kPopupStandardList=%lldLL",(long long)TClassMenuItem::kPopupStandardList).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItemcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsExternal=%lldLL",(long long)TClassMenuItem::kIsExternal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItemcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsSelf=%lldLL",(long long)TClassMenuItem::kIsSelf).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType),-1,-1,4,"fType=",0,"type flag (EClassMenuItemType)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSelfObjectPos=",0,"rang in argument list corresponding to the object being clicked on");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSelf=",0,"flag to indicate that object to be called is the selected one");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fToggle=",0,"flag toggle method");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fTitle=",0,"title if not standard");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObject),-1,-1,4,"fCalledObject=",0,"object to be called");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fFunctionName=",0,"name of the function or method to be called");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fArgs=",0,"arguments type list *** NOT CHECKED ***");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,4,"fSubMenu=",0,"list of submenu items");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fParent=",0,"parent class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDataType */
static void G__setup_memvarTDataType(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataType));
   { TDataType *p; p=(TDataType*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("TypedefInfo_t"),-1,4,"fInfo=",0,"pointer to CINT typedef info");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,"size of type");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MetaLN_EDataType),-1,-1,4,"fType=",0,"type id");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fProperty=",0,"The property information for the (potential) underlying class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fTrueName=",0,"True name of the (potential) underlying class ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFunction */
static void G__setup_memvarTFunction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TFunction));
   { TFunction *p; p=(TFunction*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("MethodInfo_t"),-1,2,"fInfo=",0,"pointer to CINT function info");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fMangledName=",0,"Mangled name as determined by CINT.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fSignature=",0,"string containing function signature");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TList),-1,-1,2,"fMethodArgs=",0,"list of function arguments");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGlobal */
static void G__setup_memvarTGlobal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TGlobal));
   { TGlobal *p; p=(TGlobal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("DataMemberInfo_t"),-1,4,"fInfo=",0,"pointer to CINT data member info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TInterpreter */
static void G__setup_memvarTInterpreter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TInterpreter));
   { TInterpreter *p; p=(TInterpreter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TInterpretercLcLEErrorCode),-1,-2,1,G__FastAllocString(2048).Format("kNoError=%lldLL",(long long)TInterpreter::kNoError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TInterpretercLcLEErrorCode),-1,-2,1,G__FastAllocString(2048).Format("kRecoverable=%lldLL",(long long)TInterpreter::kRecoverable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TInterpretercLcLEErrorCode),-1,-2,1,G__FastAllocString(2048).Format("kDangerous=%lldLL",(long long)TInterpreter::kDangerous).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TInterpretercLcLEErrorCode),-1,-2,1,G__FastAllocString(2048).Format("kFatal=%lldLL",(long long)TInterpreter::kFatal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TInterpretercLcLEErrorCode),-1,-2,1,G__FastAllocString(2048).Format("kProcessing=%lldLL",(long long)TInterpreter::kProcessing).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TIsAProxy */
static void G__setup_memvarTIsAProxy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy));
   { TIsAProxy *p; p=(TIsAProxy*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MetaLN_type_info),-1,-1,4,"fType=",0,"Actual typeid of the proxy");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MetaLN_type_info),-1,-1,4,"fLastType=",0,"Last used subtype");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fClass=",0,"Actual TClass");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,4,"fLastClass=",0,"Last used TClass");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,4,"fSubTypes[72]=",0,"map of known sub-types");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVirtual=",0,"Flag if class is virtual");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fContext=",0,"Optional user contex");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInit=",0,"Initialization flag");
   }
   G__tag_memvar_reset();
}


   /* TMethodArg */
static void G__setup_memvarTMethodArg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodArg));
   { TMethodArg *p; p=(TMethodArg*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("MethodArgInfo_t"),-1,4,"fInfo=",0,"pointer to CINT method argument info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TFunction),-1,-1,4,"fMethod=",0,"pointer to the method or global function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TDataMember),-1,-1,4,"fDataMember=",0,"TDataMember pointed by this arg,to get values and options from.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::TSchemaRule */
static void G__setup_memvarROOTcLcLTSchemaRule(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   { ROOT::TSchemaRule *p; p=(ROOT::TSchemaRule*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t),-1,-2,1,G__FastAllocString(2048).Format("kReadRule=%lldLL",(long long)ROOT::TSchemaRule::kReadRule).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t),-1,-2,1,G__FastAllocString(2048).Format("kReadRawRule=%lldLL",(long long)ROOT::TSchemaRule::kReadRawRule).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)ROOT::TSchemaRule::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fVersion=",0,"Source version string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),G__defined_typename("vector<std::pair<Int_t,Int_t> >"),-1,4,"fVersionVect=",0,"! Source version vector (for searching purposes)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fChecksum=",0,"Source checksum string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<UInt_t>"),-1,4,"fChecksumVect=",0,"! Source checksum vector (for searching purposes)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fSourceClass=",0,"Source class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fTargetClass=",0,"Target class, this is the owner of this rule object.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fTarget=",0,"Target data mamber string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fTargetVect=",0,"! Target data member vector (for searching purposes)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fSource=",0,"Source data member string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fSourceVect=",0,"! Source data member vector (for searching purposes)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fInclude=",0,"Includes string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObjArray),-1,-1,4,"fIncludeVect=",0,"! Includes vector");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fCode=",0,"User specified code snippet");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEmbed=",0,"Value determining if the rule should be embedded");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReadFuncPtr_t"),-1,4,"fReadFuncPtr=",0,"! Conversion function pointer for read rule");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReadRawFuncPtr_t"),-1,4,"fReadRawFuncPtr=",0,"! Conversion function pointer for readraw rule");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t),G__defined_typename("RuleType_t"),-1,4,"fRuleType=",0,"Type of the rule");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fAttributes=",0,"Attributes to be applied to the member (like Owner/NotOwner)");
   }
   G__tag_memvar_reset();
}


   /* ROOT::TSchemaRule::TSources */
static void G__setup_memvarROOTcLcLTSchemaRulecLcLTSources(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources));
   { ROOT::TSchemaRule::TSources *p; p=(ROOT::TSchemaRule::TSources*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,4,"fDimensions=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* vector<pair<int,int>,allocator<pair<int,int> > > */
static void G__setup_memvarvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   { vector<pair<int,int>,allocator<pair<int,int> > > *p; p=(vector<pair<int,int>,allocator<pair<int,int> > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* ROOT::TSchemaMatch */
static void G__setup_memvarROOTcLcLTSchemaMatch(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch));
   { ROOT::TSchemaMatch *p; p=(ROOT::TSchemaMatch*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerBasicType */
static void G__setup_memvarTStreamerBasicType(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType));
   { TStreamerBasicType *p; p=(TStreamerBasicType*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCounter=",0,"!value of data member when referenced by an array");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerBase */
static void G__setup_memvarTStreamerBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase));
   { TStreamerBase *p; p=(TStreamerBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBaseVersion=",0,"version number of the base class FIXME: What for? What about the schema evolution issues?");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,2,"fBaseClass=",0,"!pointer to base class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-1,2,"fNewBaseClass=",0,"!pointer to new base class if renamed");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ClassStreamerFunc_t"),-1,2,"fStreamerFunc=",0,"!Pointer to a wrapper around a custom streamer member function.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerBasicPointer */
static void G__setup_memvarTStreamerBasicPointer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer));
   { TStreamerBasicPointer *p; p=(TStreamerBasicPointer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCountVersion=",0,"version number of the class with the counter");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fCountName=",0,"name of data member holding the array count");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fCountClass=",0,"name of the class with the counter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType),-1,-1,2,"fCounter=",0,"!pointer to basic type counter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerLoop */
static void G__setup_memvarTStreamerLoop(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop));
   { TStreamerLoop *p; p=(TStreamerLoop*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCountVersion=",0,"version number of the class with the counter");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fCountName=",0,"name of data member holding the array count");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MetaLN_TString),-1,-1,2,"fCountClass=",0,"name of the class with the counter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType),-1,-1,2,"fCounter=",0,"!pointer to basic type counter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerObject */
static void G__setup_memvarTStreamerObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject));
   { TStreamerObject *p; p=(TStreamerObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerObjectAny */
static void G__setup_memvarTStreamerObjectAny(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny));
   { TStreamerObjectAny *p; p=(TStreamerObjectAny*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerObjectPointer */
static void G__setup_memvarTStreamerObjectPointer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer));
   { TStreamerObjectPointer *p; p=(TStreamerObjectPointer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerObjectAnyPointer */
static void G__setup_memvarTStreamerObjectAnyPointer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer));
   { TStreamerObjectAnyPointer *p; p=(TStreamerObjectAnyPointer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerString */
static void G__setup_memvarTStreamerString(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerString));
   { TStreamerString *p; p=(TStreamerString*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerSTL */
static void G__setup_memvarTStreamerSTL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL));
   { TStreamerSTL *p; p=(TStreamerSTL*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLcLcLdA),-1,-2,4,"kWarned=2097152LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSTLtype=",0,"type of STL vector");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCtype=",0,"STL contained type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerSTLstring */
static void G__setup_memvarTStreamerSTLstring(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring));
   { TStreamerSTLstring *p; p=(TStreamerSTLstring*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStreamerArtificial */
static void G__setup_memvarTStreamerArtificial(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial));
   { TStreamerArtificial *p; p=(TStreamerArtificial*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReadFuncPtr_t"),-1,2,"fReadFunc=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReadRawFuncPtr_t"),-1,2,"fReadRawFunc=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TToggle */
static void G__setup_memvarTToggle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggle));
   { TToggle *p; p=(TToggle*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fState=",0,"Object's state - \"a local copy\"");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fOnValue=",0,"Value recognized as switched ON (Def=1)");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fOffValue=",0,"Value recognized as switched OFF(Def=0)");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fValue=",0,"Local copy of a value returned by called function");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInitialized=",0,"True if either SetToggledObject or SetToggledVariable called - enables Toggle() method.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TObject),-1,-1,2,"fObject=",0,"The object this Toggle belongs to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,2,"fGetter=",0,"Method to Get a value of fObject;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TMethodCall),-1,-1,2,"fSetter=",0,"Method to Set a value of fObject;");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTglVariable=",0,"Alternatively: pointer to an integer value to be Toggled instead of TObjectl");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TToggleGroup */
static void G__setup_memvarTToggleGroup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup));
   { TToggleGroup *p; p=(TToggleGroup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TOrdCollection),-1,-1,4,"fToggles=",0,"list of TToggle objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MetaLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Meta() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTClass(void) {
   /* TClass */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TClass));
   G__memfunc_setup("GetClassMethod",1399,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 1, 1, 4, 0, "l - 'Long_t' 0 - faddr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassMethod",1399,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 2, 1, 4, 0, 
"C - - 10 - name C - - 10 - signature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseClassOffsetRecurse",2513,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "U 'TClass' - 10 - base", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 10, 1, 4, 0, 
"C - - 10 - name s - 'Version_t' 0 - cversion "
"U 'type_info' - 10 - info U 'TVirtualIsAProxy' - 0 - isa "
"Y - 'ShowMembersFunc_t' 0 - showmember C - - 10 - dfil "
"C - - 10 - ifil i - 'Int_t' 0 - dl "
"i - 'Int_t' 0 - il g - 'Bool_t' 0 - silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceReload",1094,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TClass' - 0 - oldcl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClassVersion",1544,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "s - 'Version_t' 0 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClassSize",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - sizof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerExternal",1670,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerTObject",1518,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerTObjectInitialized",2660,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerTObjectEmulated",2335,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerInstrumented",2117,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerStreamerInfo",2066,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerDefault",1544,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - object u 'TBuffer' - 1 - b "
"U 'TClass' - 10 - onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClass",586,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 4, 0, "u 'TClass' - 11 - tc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 1, 1, 1, 4, 0, "u 'TClass' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindStreamerInfo",1616,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 2, 1, 2, 8, 
"U 'TObjArray' - 0 - arr h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassShortTypedefHash",2427,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__MetaLN_THashTable), -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClass",586,G__G__Meta_6_0_19, 105, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClass",586,G__G__Meta_6_0_20, 105, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClass",586,G__G__Meta_6_0_21, 105, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name s - 'Version_t' 0 - cversion "
"C - - 10 '0' dfil C - - 10 '0' ifil "
"i - 'Int_t' 0 '0' dl i - 'Int_t' 0 '0' il "
"g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClass",586,G__G__Meta_6_0_22, 105, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 10, 1, 1, 0, 
"C - - 10 - name s - 'Version_t' 0 - cversion "
"u 'type_info' - 11 - info U 'TVirtualIsAProxy' - 0 - isa "
"Y - 'ShowMembersFunc_t' 0 - showmember C - - 10 - dfil "
"C - - 10 - ifil i - 'Int_t' 0 - dl "
"i - 'Int_t' 0 - il g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInstance",1086,G__G__Meta_6_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' heap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddImplFile",1051,G__G__Meta_6_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename i - - 0 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRef",550,G__G__Meta_6_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClassRef' - 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRule",673,G__G__Meta_6_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "C - - 10 - rule", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*))(&TClass::AddRule) ), 0);
   G__memfunc_setup("ReadRules",903,G__G__Meta_6_0_27, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*))(&TClass::ReadRules) ), 0);
   G__memfunc_setup("ReadRules",903,G__G__Meta_6_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TClass::ReadRules) ), 0);
   G__memfunc_setup("AdoptSchemaRules",1620,G__G__Meta_6_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "U 'ROOT::TSchemaRuleSet' - 0 - rules", (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("BuildRealData",1262,G__G__Meta_6_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 '0' pointer g - 'Bool_t' 0 'kFALSE' isTransient", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildEmulatedRealData",2079,G__G__Meta_6_0_32, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - name l - 'Long_t' 0 - offset "
"U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateStreamerOffset",2360,G__G__Meta_6_0_33, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CallShowMembers",1512,G__G__Meta_6_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"Y - - 0 - obj u 'TMemberInspector' - 1 - insp "
"i - 'Int_t' 0 '-1' isATObject", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanSplit",798,G__G__Meta_6_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanIgnoreTObjectStreamer",2404,G__G__Meta_6_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyCollectionProxy",1993,G__G__Meta_6_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVirtualCollectionProxy' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dump",406,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dump",406,G__G__Meta_6_0_41, 121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EscapeChars",1090,G__G__Meta_6_0_42, 67, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindStreamerInfo",1616,G__G__Meta_6_0_43, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConversionStreamerInfo",2581,G__G__Meta_6_0_44, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 2, 1, 1, 8, 
"C - - 10 - onfile_classname i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindConversionStreamerInfo",2678,G__G__Meta_6_0_45, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 2, 1, 1, 8, 
"C - - 10 - onfile_classname h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConversionStreamerInfo",2581,G__G__Meta_6_0_46, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 2, 1, 1, 8, 
"U 'TClass' - 10 - onfile_cl i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindConversionStreamerInfo",2678,G__G__Meta_6_0_47, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 2, 1, 1, 8, 
"U 'TClass' - 10 - onfile_cl h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasDefaultConstructor",2183,G__G__Meta_6_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheckSum",1075,G__G__Meta_6_0_49, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 '0' code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollectionProxy",1870,G__G__Meta_6_0_50, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualCollectionProxy), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIsAProxy",1087,G__G__Meta_6_0_51, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualIsAProxy), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassVersion",1532,G__G__Meta_6_0_52, 115, -1, G__defined_typename("Version_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataMember",1266,G__G__Meta_6_0_53, 85, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 0, 1, 1, 1, 8, "C - - 10 - datamember", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataMemberOffset",1881,G__G__Meta_6_0_54, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "C - - 10 - membername", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeclFileName",1433,G__G__Meta_6_0_55, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeclFileLine",1440,G__G__Meta_6_0_56, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDelete",883,G__G__Meta_6_0_57, 89, -1, G__defined_typename("ROOT::DelFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDestructor",1359,G__G__Meta_6_0_58, 89, -1, G__defined_typename("ROOT::DesFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeleteArray",1394,G__G__Meta_6_0_59, 89, -1, G__defined_typename("ROOT::DelArrFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassInfo",1186,G__G__Meta_6_0_60, 89, -1, G__defined_typename("ClassInfo_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContextMenuTitle",1948,G__G__Meta_6_0_61, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentStreamerInfo",2258,G__G__Meta_6_0_62, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfDataMembers",1974,G__G__Meta_6_0_63, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfBases",1375,G__G__Meta_6_0_64, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMethods",1605,G__G__Meta_6_0_65, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfRealData",1647,G__G__Meta_6_0_66, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfAllPublicMethods",2493,G__G__Meta_6_0_67, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfAllPublicDataMembers",2862,G__G__Meta_6_0_68, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImplFileName",1459,G__G__Meta_6_0_69, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImplFileLine",1466,G__G__Meta_6_0_70, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActualClass",1392,G__G__Meta_6_0_71, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 8, "Y - - 10 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseClass",1169,G__G__Meta_6_0_72, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 0, "C - - 10 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseClass",1169,G__G__Meta_6_0_73, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - base", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseClassOffset",1784,G__G__Meta_6_0_74, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TClass' - 10 - base", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseDataMember",1645,G__G__Meta_6_0_75, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 0, "C - - 10 - datamember", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectoryAutoAdd",1911,G__G__Meta_6_0_76, 89, -1, G__defined_typename("ROOT::DirAutoAdd_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInstanceCount",1630,G__G__Meta_6_0_77, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeapInstanceCount",2012,G__G__Meta_6_0_78, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuItems",1207,G__G__Meta_6_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - listitems", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuList",1105,G__G__Meta_6_0_80, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__Meta_6_0_81, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 2, 1, 1, 0, 
"C - - 10 - method C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodWithPrototype",2291,G__G__Meta_6_0_82, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 2, 1, 1, 0, 
"C - - 10 - method C - - 10 - proto", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodAny",1193,G__G__Meta_6_0_83, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 1, 1, 1, 0, "C - - 10 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodAllAny",1474,G__G__Meta_6_0_84, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 1, 1, 1, 0, "C - - 10 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdata",776,G__G__Meta_6_0_85, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNew",586,G__G__Meta_6_0_86, 89, -1, G__defined_typename("ROOT::NewFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewArray",1097,G__G__Meta_6_0_87, 89, -1, G__defined_typename("ROOT::NewArrFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNmethods",1122,G__G__Meta_6_0_88, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRealData",1054,G__G__Meta_6_0_89, 85, G__get_linked_tagnum(&G__G__MetaLN_TRealData), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReferenceProxy",1745,G__G__Meta_6_0_90, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualRefProxy), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSchemaRules",1404,G__G__Meta_6_0_91, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSchemaRules",1404,G__G__Meta_6_0_92, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' create", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSharedLibs",1281,G__G__Meta_6_0_93, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowMembersWrapper",2157,G__G__Meta_6_0_94, 89, -1, G__defined_typename("ShowMembersFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamer",1123,G__G__Meta_6_0_95, 85, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamerFunc",1519,G__G__Meta_6_0_96, 89, -1, G__defined_typename("ClassStreamerFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamerInfos",1634,G__G__Meta_6_0_97, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamerInfo",1519,G__G__Meta_6_0_98, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeInfo",1102,G__G__Meta_6_0_99, 85, G__get_linked_tagnum(&G__G__MetaLN_type_info), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IgnoreTObjectStreamer",2130,G__G__Meta_6_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ignore", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InheritsFrom",1242,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InheritsFrom",1242,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InterpretedShowMembers",2290,G__G__Meta_6_0_103, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - obj u 'TMemberInspector' - 1 - insp", (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("IsLoaded",773,G__G__Meta_6_0_105, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsForeign",902,G__G__Meta_6_0_106, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStartingWithTObject",2127,G__G__Meta_6_0_107, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTObject",871,G__G__Meta_6_0_108, 103, -1, G__defined_typename("Bool_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 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCustomMenuList",1834,G__G__Meta_6_0_110, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Move",407,G__G__Meta_6_0_111, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - - 0 - arenaFrom Y - - 0 - arenaTo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("New",298,G__G__Meta_6_0_112, 89, -1, -1, 0, 1, 1, 1, 8, "i 'TClass::ENewType' - 0 'kClassNew' defConstructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("New",298,G__G__Meta_6_0_113, 89, -1, -1, 0, 2, 1, 1, 8, 
"Y - - 0 - arena i 'TClass::ENewType' - 0 'kClassNew' defConstructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewArray",809,G__G__Meta_6_0_114, 89, -1, -1, 0, 2, 1, 1, 8, 
"l - 'Long_t' 0 - nElements i 'TClass::ENewType' - 0 'kClassNew' defConstructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewArray",809,G__G__Meta_6_0_115, 89, -1, -1, 0, 3, 1, 1, 8, 
"l - 'Long_t' 0 - nElements Y - - 0 - arena "
"i 'TClass::ENewType' - 0 'kClassNew' defConstructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PostLoadCheck",1284,G__G__Meta_6_0_116, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__Meta_6_0_118, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - pointer "
"i - 'Int_t' 0 - version h - 'UInt_t' 0 - start "
"h - 'UInt_t' 0 - count", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBuffer",982,G__G__Meta_6_0_119, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - pointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveRef",907,G__G__Meta_6_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClassRef' - 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReplaceWith",1112,G__G__Meta_6_0_121, 121, -1, -1, 0, 2, 1, 1, 8, 
"U 'TClass' - 0 - newcl g - 'Bool_t' 0 'kTRUE' recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetClassInfo",1413,G__G__Meta_6_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - tagnum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetInstanceCount",1857,G__G__Meta_6_0_123, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetMenuList",1332,G__G__Meta_6_0_124, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Size",411,G__G__Meta_6_0_125, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCollectionProxy",1882,G__G__Meta_6_0_126, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::TCollectionProxyInfo' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetContextMenuTitle",1960,G__G__Meta_6_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentStreamerInfo",2270,G__G__Meta_6_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalIsA",1146,G__G__Meta_6_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'IsAGlobalFunc_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDeclFile",1060,G__G__Meta_6_0_130, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i - - 0 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDelete",895,G__G__Meta_6_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::DelFunc_t' 0 - deleteFunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDeleteArray",1406,G__G__Meta_6_0_132, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::DelArrFunc_t' 0 - deleteArrayFunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectoryAutoAdd",1923,G__G__Meta_6_0_133, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::DirAutoAdd_t' 0 - dirAutoAddFunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDestructor",1371,G__G__Meta_6_0_134, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::DesFunc_t' 0 - destructorFunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetImplFileName",1471,G__G__Meta_6_0_135, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - implFileName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNew",598,G__G__Meta_6_0_136, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::NewFunc_t' 0 - newFunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNewArray",1109,G__G__Meta_6_0_137, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::NewArrFunc_t' 0 - newArrayFunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStreamerInfo",1531,G__G__Meta_6_0_138, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - version C - - 10 '\"\"' info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUnloaded",1112,G__G__Meta_6_0_139, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBuffer",1125,G__G__Meta_6_0_140, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - pointer "
"C - - 10 '\"\"' info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdoptReferenceProxy",1961,G__G__Meta_6_0_141, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualRefProxy' - 0 - proxy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdoptStreamer",1339,G__G__Meta_6_0_142, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClassStreamer' - 0 - strm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdoptMemberStreamer",1939,G__G__Meta_6_0_143, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TMemberStreamer' - 0 - strm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMemberStreamer",1735,G__G__Meta_6_0_144, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name Y - 'MemberStreamerFunc_t' 0 - strm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStreamerFunc",1531,G__G__Meta_6_0_145, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ClassStreamerFunc_t' 0 - strm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClass",767,G__G__Meta_6_0_146, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (void (*)(TClass*))(&TClass::AddClass) ), 0);
   G__memfunc_setup("RemoveClass",1124,G__G__Meta_6_0_147, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (void (*)(TClass*))(&TClass::RemoveClass) ), 0);
   G__memfunc_setup("GetClass",790,G__G__Meta_6_0_148, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 3, 3, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' load "
"g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) G__func2void( (TClass* (*)(const char*, Bool_t, Bool_t))(&TClass::GetClass) ), 0);
   G__memfunc_setup("GetClass",790,G__G__Meta_6_0_149, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 3, 3, 1, 0, 
"u 'type_info' - 11 - typeinfo g - 'Bool_t' 0 'kTRUE' load "
"g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) G__func2void( (TClass* (*)(const type_info&, Bool_t, Bool_t))(&TClass::GetClass) ), 0);
   G__memfunc_setup("GetDict",676,G__G__Meta_6_0_150, 89, -1, G__defined_typename("VoidFuncPtr_t"), 0, 1, 3, 1, 0, "C - - 10 - cname", (char*)NULL, (void*) G__func2void( (VoidFuncPtr_t (*)(const char*))(&TClass::GetDict) ), 0);
   G__memfunc_setup("GetDict",676,G__G__Meta_6_0_151, 89, -1, G__defined_typename("VoidFuncPtr_t"), 0, 1, 3, 1, 0, "u 'type_info' - 11 - info", (char*)NULL, (void*) G__func2void( (VoidFuncPtr_t (*)(const type_info&))(&TClass::GetDict) ), 0);
   G__memfunc_setup("AutoBrowse",1035,G__G__Meta_6_0_152, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"U 'TObject' - 0 - obj U 'TBrowser' - 0 - browser", (char*)NULL, (void*) G__func2void( (Int_t (*)(TObject*, TBrowser*))(&TClass::AutoBrowse) ), 0);
   G__memfunc_setup("IsCallingNew",1184,G__G__Meta_6_0_153, 105, G__get_linked_tagnum(&G__G__MetaLN_TClasscLcLENewType), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass::ENewType (*)())(&TClass::IsCallingNew) ), 0);
   G__memfunc_setup("Load",384,G__G__Meta_6_0_154, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 3, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) G__func2void( (TClass* (*)(TBuffer&))(&TClass::Load) ), 0);
   G__memfunc_setup("Store",525,G__G__Meta_6_0_155, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,G__G__Meta_6_0_156, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"Y - - 0 - obj U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteArray",1106,G__G__Meta_6_0_157, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - ary g - 'Bool_t' 0 'kFALSE' dtorOnly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Destructor",1071,G__G__Meta_6_0_158, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - obj g - 'Bool_t' 0 'kFALSE' dtorOnly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DynamicCast",1104,G__G__Meta_6_0_159, 89, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 10 - base Y - - 0 - obj "
"g - 'Bool_t' 0 'kTRUE' up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,G__G__Meta_6_0_160, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "Y - - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Meta_6_0_161, 121, -1, -1, 0, 3, 1, 1, 8, 
"Y - - 0 - obj u 'TBuffer' - 1 - b "
"U 'TClass' - 10 '0' onfile_class", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_6_0_162, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TClass::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_6_0_163, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClass::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_6_0_164, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TClass::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_6_0_165, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClass::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_6_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_6_0_170, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClass::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_6_0_171, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClass::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_6_0_172, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClass::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_6_0_173, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClass::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TClass", 712, G__G__Meta_6_0_174, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTClassStreamer(void) {
   /* TClassStreamer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer));
   G__memfunc_setup("TClassStreamer",1421,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassStreamer",1421,G__G__Meta_15_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 1, 1, 1, 0, "Y - 'ClassStreamerFunc_t' 0 - pointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassStreamer",1421,G__G__Meta_15_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 1, 1, 1, 0, "u 'TClassStreamer' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOnFileClass",1375,G__G__Meta_15_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOnFileClass",1363,G__G__Meta_15_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Generate",811,G__G__Meta_15_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Meta_15_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - objp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stream",620,G__G__Meta_15_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - objp "
"U 'TClass' - 10 - onfileClass", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~TClassStreamer", 1547, G__G__Meta_15_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_15_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 1, 1, 1, 1, 0, "u 'TClassStreamer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMemberStreamer(void) {
   /* TMemberStreamer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer));
   G__memfunc_setup("TMemberStreamer",1519,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMemberStreamer",1519,G__G__Meta_16_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer), -1, 0, 1, 1, 1, 0, "Y - 'MemberStreamerFunc_t' 0 - pointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMemberStreamer",1519,G__G__Meta_16_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer), -1, 0, 1, 1, 1, 0, "u 'TMemberStreamer' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOnFileClass",1375,G__G__Meta_16_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOnFileClass",1363,G__G__Meta_16_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Meta_16_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b Y - - 0 - pmember "
"i - 'Int_t' 0 '0' size", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~TMemberStreamer", 1645, G__G__Meta_16_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_16_0_8, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer), -1, 1, 1, 1, 1, 0, "u 'TMemberStreamer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualIsAProxy(void) {
   /* TVirtualIsAProxy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TVirtualIsAProxy));
   G__memfunc_setup("SetClass",802,G__G__Meta_18_0_1, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator()",957,G__G__Meta_18_0_2, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 0, "Y - - 10 - obj", (char*)NULL, (void*) NULL, 3);
   // automatic destructor
   G__memfunc_setup("~TVirtualIsAProxy", 1752, G__G__Meta_18_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_18_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TVirtualIsAProxy), -1, 1, 1, 1, 1, 0, "u 'TVirtualIsAProxy' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOT(void) {
   /* ROOT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOT));
   G__memfunc_setup("CreateClass",1098,G__G__Meta_19_0_1, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 9, 1, 1, 0, 
"C - - 10 - cname s - 'Version_t' 0 - id "
"u 'type_info' - 11 - info U 'TVirtualIsAProxy' - 0 - isa "
"Y - 'ShowMembersFunc_t' 0 - show C - - 10 - dfil "
"C - - 10 - ifil i - 'Int_t' 0 - dl "
"i - 'Int_t' 0 - il", (char*)NULL, (void*) G__func2void( (TClass* (*)(const char*, Version_t, const type_info&, TVirtualIsAProxy*, ShowMembersFunc_t, const char*, const char*, Int_t, Int_t))(&ROOT::CreateClass) ), 0);
   G__memfunc_setup("AddClass",767,G__G__Meta_19_0_2, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - cname s - 'Version_t' 0 - id "
"u 'type_info' - 11 - info Y - 'VoidFuncPtr_t' 0 - dict "
"i - 'Int_t' 0 - pragmabits", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Version_t, const type_info&, VoidFuncPtr_t, Int_t))(&ROOT::AddClass) ), 0);
   G__memfunc_setup("RemoveClass",1124,G__G__Meta_19_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - cname", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&ROOT::RemoveClass) ), 0);
   G__memfunc_setup("ResetClassVersion",1759,G__G__Meta_19_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - - C - - 10 - - "
"s - 'Short_t' 0 - -", (char*)NULL, (void*) G__func2void( (void (*)(TClass*, const char*, Short_t))(&ROOT::ResetClassVersion) ), 0);
   G__memfunc_setup("RegisterClassTemplate",2167,G__G__Meta_19_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TNamed), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - file "
"i - 'Int_t' 0 - line", (char*)NULL, (void*) G__func2void( (TNamed* (*)(const char*, const char*, Int_t))(&ROOT::RegisterClassTemplate) ), 0);
   G__memfunc_setup("DefineBehavior",1403,G__G__Meta_19_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTInitBehavior), -1, 0, 2, 1, 1, 1, 
"Y - - 0 - - Y - - 0 - -", (char*)NULL, (void*) G__func2void( (const ROOT::TInitBehavior* (*)(void*, void*))(&ROOT::DefineBehavior) ), 0);
   G__memfunc_setup("CreateClass",1098,G__G__Meta_19_0_7, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 6, 1, 1, 0, 
"C - - 10 - cname s - 'Version_t' 0 - id "
"C - - 10 - dfil C - - 10 - ifil "
"i - 'Int_t' 0 - dl i - 'Int_t' 0 - il", (char*)NULL, (void*) G__func2void( (TClass* (*)(const char*, Version_t, const char*, const char*, Int_t, Int_t))(&ROOT::CreateClass) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMethod(void) {
   /* TMethod */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethod));
   G__memfunc_setup("CreateSignature",1542,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TMethod",693,G__G__Meta_79_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 2, 1, 1, 0, 
"Y - 'MethodInfo_t' 0 '0' info U 'TClass' - 0 '0' cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMethod",693,G__G__Meta_79_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 0, 1, 1, 1, 0, "u 'TMethod' - 11 - org", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_79_0_4, 117, G__get_linked_tagnum(&G__G__MetaLN_TMethod), -1, 1, 1, 1, 1, 0, "u 'TMethod' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,G__G__Meta_79_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMenuItem",992,G__G__Meta_79_0_7, 105, G__get_linked_tagnum(&G__G__MetaLN_EMenuItemKind), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCommentString",1642,G__G__Meta_79_0_8, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Getter",619,G__G__Meta_79_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetterMethod",1228,G__G__Meta_79_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetterMethod",1240,G__G__Meta_79_0_11, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindDataMember",1363,G__G__Meta_79_0_12, 85, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfMethodArgs",1887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMenuItem",1104,G__G__Meta_79_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EMenuItemKind' - 0 - menuItem", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_79_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMethod::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_79_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethod::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_79_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMethod::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_79_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMethod::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_79_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__Meta_79_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethod::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_79_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethod::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_79_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethod::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_79_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethod::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMethod", 819, G__G__Meta_79_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualStreamerInfo(void) {
   /* TVirtualStreamerInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 1, 1, 1, 2, 0, "u 'TVirtualStreamerInfo' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,G__G__Meta_84_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("BuildCheck",974,G__G__Meta_84_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("BuildEmulated",1313,G__G__Meta_84_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("BuildOld",783,G__G__Meta_84_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("BuildFor",791,G__G__Meta_84_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CallShowMembers",1512,G__G__Meta_84_0_10, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - - 0 - obj u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CompareContent",1442,G__G__Meta_84_0_12, 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, 3);
   G__memfunc_setup("Compile",713,G__G__Meta_84_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ForceWriteInfo",1414,G__G__Meta_84_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 - file g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GenerateHeaderFile",1780,G__G__Meta_84_0_15, 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, 3);
   G__memfunc_setup("GetActualClass",1392,G__G__Meta_84_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 8, "Y - - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetClass",790,G__G__Meta_84_0_17, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCheckSum",1075,G__G__Meta_84_0_18, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetClassVersion",1532,G__G__Meta_84_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetElems",790,G__G__Meta_84_0_20, 75, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetElements",1117,G__G__Meta_84_0_21, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetOffset",903,G__G__Meta_84_0_22, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetOffsets",1018,G__G__Meta_84_0_23, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetOldVersion",1317,G__G__Meta_84_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetOnFileClassVersion",2105,G__G__Meta_84_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNumber",905,G__G__Meta_84_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSize",699,G__G__Meta_84_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetStreamerElement",1837,G__G__Meta_84_0_28, 85, G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement), -1, 0, 2, 1, 1, 8, 
"C - - 10 - datamember i - 'Int_t' 1 - offset", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsBuilt",700,G__G__Meta_84_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCompiled",1001,G__G__Meta_84_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOptimized",1137,G__G__Meta_84_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRecovered",1115,G__G__Meta_84_0_32, 105, -1, G__defined_typename("Int_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 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("NewInfo",694,G__G__Meta_84_0_34, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("New",298,G__G__Meta_84_0_35, 89, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("NewArray",809,G__G__Meta_84_0_36, 89, -1, -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - nElements Y - - 0 '0' ary", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Destructor",1071,G__G__Meta_84_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - p g - 'Bool_t' 0 'kFALSE' dtorOnly", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeleteArray",1106,G__G__Meta_84_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - p g - 'Bool_t' 0 'kFALSE' dtorOnly", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCheckSum",1087,G__G__Meta_84_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetClass",802,G__G__Meta_84_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetClassVersion",1544,G__G__Meta_84_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vers", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetStreamMemberWise",1928,G__G__Meta_84_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Bool_t))(&TVirtualStreamerInfo::SetStreamMemberWise) ), 0);
   G__memfunc_setup("TagFile",668,G__G__Meta_84_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - fFile", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Update",611,G__G__Meta_84_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - oldClass U 'TClass' - 0 - newClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetElementCounter",1738,G__G__Meta_84_0_45, 85, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType), -1, 0, 2, 3, 1, 0, 
"C - - 10 - countName U 'TClass' - 0 - cl", (char*)NULL, (void*) G__func2void( (TStreamerBasicType* (*)(const char*, TClass*))(&TVirtualStreamerInfo::GetElementCounter) ), 0);
   G__memfunc_setup("CanOptimize",1123,G__G__Meta_84_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TVirtualStreamerInfo::CanOptimize) ), 0);
   G__memfunc_setup("GetStreamMemberWise",1916,G__G__Meta_84_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TVirtualStreamerInfo::GetStreamMemberWise) ), 0);
   G__memfunc_setup("Optimize",849,G__G__Meta_84_0_48, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' opt", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TVirtualStreamerInfo::Optimize) ), 0);
   G__memfunc_setup("CanDelete",869,G__G__Meta_84_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TVirtualStreamerInfo::CanDelete) ), 0);
   G__memfunc_setup("SetCanDelete",1169,G__G__Meta_84_0_50, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' opt", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TVirtualStreamerInfo::SetCanDelete) ), 0);
   G__memfunc_setup("SetFactory",1028,G__G__Meta_84_0_51, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualStreamerInfo' - 0 - factory", (char*)NULL, (void*) G__func2void( (void (*)(TVirtualStreamerInfo*))(&TVirtualStreamerInfo::SetFactory) ), 0);
   G__memfunc_setup("GenEmulatedProxy",1645,G__G__Meta_84_0_52, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualCollectionProxy), -1, 0, 1, 1, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GenEmulatedClassStreamer",2436,G__G__Meta_84_0_53, 85, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 1, 1, 1, 0, "C - - 10 - class_name", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GenExplicitProxy",1662,G__G__Meta_84_0_54, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualCollectionProxy), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GenExplicitClassStreamer",2453,G__G__Meta_84_0_55, 85, G__get_linked_tagnum(&G__G__MetaLN_TClassStreamer), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::TCollectionProxyInfo' - 11 - info U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Factory",728,G__G__Meta_84_0_56, 85, G__get_linked_tagnum(&G__G__MetaLN_TVirtualStreamerInfo), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualStreamerInfo* (*)())(&TVirtualStreamerInfo::Factory) ), 0);
   G__memfunc_setup("Class",502,G__G__Meta_84_0_57, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualStreamerInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_84_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualStreamerInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_84_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualStreamerInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_84_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualStreamerInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_84_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_84_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualStreamerInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_84_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualStreamerInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_84_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualStreamerInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_84_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualStreamerInfo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualStreamerInfo", 2184, G__G__Meta_84_0_69, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerElement(void) {
   /* TStreamerElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement));
   G__memfunc_setup("TStreamerElement",1633,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement), -1, 0, 1, 1, 4, 0, "u 'TStreamerElement' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement), -1, 1, 1, 1, 4, 0, "u 'TStreamerElement' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerElement",1633,G__G__Meta_85_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerElement",1633,G__G__Meta_85_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerElement), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset i - 'Int_t' 0 - dtype "
"C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CannotSplit",1135,G__G__Meta_85_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArrayDim",1081,G__G__Meta_85_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArrayLength",1409,G__G__Meta_85_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassPointer",1527,G__G__Meta_85_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,G__G__Meta_85_0_9, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExecID",818,G__G__Meta_85_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFullName",1076,G__G__Meta_85_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInclude",996,G__G__Meta_85_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxIndex",1086,G__G__Meta_85_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__Meta_85_0_14, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStreamer",1123,G__G__Meta_85_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Meta_85_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNewType",1004,G__G__Meta_85_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewClass",1088,G__G__Meta_85_0_18, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Meta_85_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffset",903,G__G__Meta_85_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTObjectOffset",1586,G__G__Meta_85_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,G__G__Meta_85_0_22, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeNameBasic",1573,G__G__Meta_85_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFactor",895,G__G__Meta_85_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmin",700,G__G__Meta_85_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmax",702,G__G__Meta_85_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__Meta_85_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsaPointer",1022,G__G__Meta_85_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCounter",1020,G__G__Meta_85_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOldFormat",1092,G__G__Meta_85_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - newTypeName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsBase",567,G__G__Meta_85_0_31, 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("SetArrayDim",1093,G__G__Meta_85_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxIndex",1098,G__G__Meta_85_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - dim i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOffset",915,G__G__Meta_85_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTObjectOffset",1598,G__G__Meta_85_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tobjoffset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStreamer",1135,G__G__Meta_85_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMemberStreamer' - 0 - streamer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSize",711,G__G__Meta_85_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNewType",1016,G__G__Meta_85_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dtype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNewClass",1100,G__G__Meta_85_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetType",718,G__G__Meta_85_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dtype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTypeName",1103,G__G__Meta_85_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Meta_85_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - oldClass U 'TClass' - 0 - newClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_85_0_44, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_85_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_85_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_85_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_85_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_85_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_85_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_85_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_85_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerElement", 1759, G__G__Meta_85_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDictionary(void) {
   /* TDictionary */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TDictionary));
   G__memfunc_setup("Property",869,G__G__Meta_111_0_3, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Meta_111_0_4, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDictionary::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_111_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDictionary::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_111_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDictionary::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_111_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDictionary::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_111_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_111_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDictionary::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_111_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDictionary::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_111_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDictionary::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_111_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDictionary::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDictionary", 1256, G__G__Meta_111_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_111_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TDictionary), -1, 1, 1, 1, 1, 0, "u 'TDictionary' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBaseClass(void) {
   /* TBaseClass */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TBaseClass));
   G__memfunc_setup("TBaseClass",965,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TBaseClass), -1, 0, 1, 1, 4, 0, "u 'TBaseClass' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TBaseClass), -1, 1, 1, 1, 4, 0, "u 'TBaseClass' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TBaseClass",965,G__G__Meta_122_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TBaseClass), -1, 0, 2, 1, 1, 0, 
"Y - 'BaseClassInfo_t' 0 '0' info U 'TClass' - 0 '0' cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClassPointer",1527,G__G__Meta_122_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDelta",778,G__G__Meta_122_0_7, 105, -1, G__defined_typename("Int_t"), 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("IsSTLContainer",1362,G__G__Meta_122_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_122_0_11, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBaseClass::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_122_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBaseClass::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_122_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBaseClass::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_122_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBaseClass::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_122_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__Meta_122_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBaseClass::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_122_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBaseClass::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_122_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBaseClass::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_122_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBaseClass::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBaseClass", 1091, G__G__Meta_122_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDataMember(void) {
   /* TDataMember */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataMember));
   G__memfunc_setup("TDataMember",1062,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 0, 1, 1, 2, 0, "u 'TDataMember' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 1, 1, 1, 2, 0, "u 'TDataMember' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataMember",1062,G__G__Meta_123_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 0, 2, 1, 1, 0, 
"Y - 'DataMemberInfo_t' 0 '0' info U 'TClass' - 0 '0' cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArrayDim",1081,G__G__Meta_123_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxIndex",1086,G__G__Meta_123_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Meta_123_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataType",1084,G__G__Meta_123_0_7, 85, G__get_linked_tagnum(&G__G__MetaLN_TDataType), -1, 0, 0, 1, 1, 8, "", "only for basic type", (void*) NULL, 0);
   G__memfunc_setup("GetOffset",903,G__G__Meta_123_0_8, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffsetCint",1301,G__G__Meta_123_0_9, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,G__G__Meta_123_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFullTypeName",1494,G__G__Meta_123_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrueTypeName",1507,G__G__Meta_123_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArrayIndex",1303,G__G__Meta_123_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnitSize",1115,G__G__Meta_123_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,G__G__Meta_123_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetterMethod",1240,G__G__Meta_123_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetterMethod",1228,G__G__Meta_123_0_17, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 '0' cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBasic",670,G__G__Meta_123_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEnum",593,G__G__Meta_123_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsaPointer",1022,G__G__Meta_123_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsPersistent",1261,G__G__Meta_123_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSTLContainer",1362,G__G__Meta_123_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_123_0_24, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDataMember::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_123_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataMember::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_123_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDataMember::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_123_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDataMember::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_123_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_123_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataMember::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_123_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataMember::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_123_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataMember::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_123_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataMember::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDataMember", 1188, G__G__Meta_123_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTClassRef(void) {
   /* TClassRef */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassRef));
   G__memfunc_setup("Assign",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TClassRef' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Assign",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TClass' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InternalGetClass",1619,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ListReset",927,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassRef",871,G__G__Meta_124_0_5, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassRef), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassRef",871,G__G__Meta_124_0_6, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassRef), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassRef",871,G__G__Meta_124_0_7, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassRef), -1, 0, 1, 1, 1, 0, "C - - 10 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassRef",871,G__G__Meta_124_0_8, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassRef), -1, 0, 1, 1, 1, 0, "u 'TClassRef' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_124_0_9, 117, G__get_linked_tagnum(&G__G__MetaLN_TClassRef), -1, 1, 1, 1, 1, 0, "u 'TClassRef' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_124_0_10, 117, G__get_linked_tagnum(&G__G__MetaLN_TClassRef), -1, 1, 1, 1, 1, 0, "U 'TClass' - 0 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,G__G__Meta_124_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - new_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassName",1175,G__G__Meta_124_0_12, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Meta_124_0_13, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Meta_124_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Meta_124_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator TClass*",1536,G__G__Meta_124_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TClassRef", 997, G__G__Meta_124_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRealData(void) {
   /* TRealData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TRealData));
   G__memfunc_setup("TRealData",850,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TRealData), -1, 0, 1, 1, 4, 0, "u 'TRealData' - 11 - rhs", "Copying TRealData in not allowed.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TRealData), -1, 1, 1, 1, 4, 0, "u 'TRealData' - 11 - rhs", "Copying TRealData in not allowed.", (void*) NULL, 0);
   G__memfunc_setup("TRealData",850,G__G__Meta_125_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TRealData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRealData",850,G__G__Meta_125_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TRealData), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name l - 'Long_t' 0 - offset "
"U 'TDataMember' - 0 - datamember", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdoptStreamer",1339,G__G__Meta_125_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMemberStreamer' - 0 - p", (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("GetDataMember",1266,G__G__Meta_125_0_7, 85, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamer",1123,G__G__Meta_125_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TMemberStreamer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThisOffset",1311,G__G__Meta_125_0_9, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsObject",787,G__G__Meta_125_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsObject",1087,G__G__Meta_125_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isObject", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRealData",1289,G__G__Meta_125_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - pointer C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_125_0_13, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRealData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_125_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRealData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_125_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRealData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_125_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRealData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_125_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__Meta_125_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRealData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_125_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRealData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_125_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRealData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_125_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRealData::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRealData", 976, G__G__Meta_125_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMethodCall(void) {
   /* TMethodCall */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodCall));
   G__memfunc_setup("Execute",723,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"C - - 10 - - C - - 10 - - "
"I - - 0 '0' -", "versions of TObject", (void*) NULL, 1);
   G__memfunc_setup("Execute",723,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"U 'TMethod' - 0 - - U 'TObjArray' - 0 - - "
"I - - 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitImplementation",1882,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"C - - 10 - methodname C - - 10 - params "
"C - - 10 - proto U 'TClass' - 0 - cl "
"Y - 'ClassInfo_t' 10 - cinfo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMethodCall",1073,G__G__Meta_127_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMethodCall",1073,G__G__Meta_127_0_5, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMethodCall",1073,G__G__Meta_127_0_6, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 2, 1, 1, 0, 
"C - - 10 - function C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMethodCall",1073,G__G__Meta_127_0_7, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 1, 1, 1, 0, "u 'TMethodCall' - 11 - org", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_127_0_8, 117, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 1, 1, 1, 1, 0, "u 'TMethodCall' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__Meta_127_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__Meta_127_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - function C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitWithPrototype",1798,G__G__Meta_127_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - proto", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitWithPrototype",1798,G__G__Meta_127_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - function C - - 10 - proto", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Meta_127_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallDtorOnly",1207,G__G__Meta_127_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__Meta_127_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TFunction), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodName",1282,G__G__Meta_127_0_17, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParams",900,G__G__Meta_127_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProto",820,G__G__Meta_127_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReturnType",1058,G__G__Meta_127_0_20, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodCallcLcLEReturnType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParamPtrs",1222,G__G__Meta_127_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - paramArr i - 'Int_t' 0 '-1' nparam", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetParam",1012,G__G__Meta_127_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParam",797,G__G__Meta_127_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParam",797,G__G__Meta_127_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParam",797,G__G__Meta_127_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ll", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParam",797,G__G__Meta_127_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 0 - ull", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - object C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - object l - 'Long_t' 1 - retLong", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_30, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - object C - - 10 - params "
"l - 'Long_t' 1 - retLong", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - object d - 'Double_t' 1 - retDouble", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_32, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - object C - - 10 - params "
"d - 'Double_t' 1 - retDouble", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - object C - - 2 - retText", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - object C - - 10 - params "
"C - - 2 - retText", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 1 - retLong", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - params l - 'Long_t' 1 - retLong", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 1 - retDouble", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Meta_127_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - params d - 'Double_t' 1 - retDouble", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_127_0_41, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMethodCall::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_127_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodCall::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_127_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMethodCall::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_127_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMethodCall::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_127_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_127_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodCall::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_127_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethodCall::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_127_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodCall::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_127_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethodCall::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMethodCall", 1199, G__G__Meta_127_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLTSchemaRuleSet(void) {
   /* ROOT::TSchemaRuleSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet));
   G__memfunc_setup("TSchemaRuleSet",1385,G__G__Meta_130_0_1, 105, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRule",673,G__G__Meta_130_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'ROOT::TSchemaRule' - 0 - rule i 'ROOT::TSchemaRuleSet::EConsistencyCheck' - 0 'kCheckAll' checkConsistency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRules",788,G__G__Meta_130_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'ROOT::TSchemaRuleSet' - 0 - rules i 'ROOT::TSchemaRuleSet::EConsistencyCheck' - 0 'kCheckAll' checkConsistency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasRuleWithSourceClass",2231,G__G__Meta_130_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TString' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRules",908,G__G__Meta_130_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 1, 1, 1, 9, "u 'TString' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRules",908,G__G__Meta_130_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch), -1, 0, 2, 1, 1, 9, 
"u 'TString' - 11 - source i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRules",908,G__G__Meta_130_0_7, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch), -1, 0, 2, 1, 1, 9, 
"u 'TString' - 11 - source h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRules",908,G__G__Meta_130_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch), -1, 0, 3, 1, 1, 9, 
"u 'TString' - 11 - source i - 'Int_t' 0 - version "
"h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Meta_130_0_9, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassCheckSum",1577,G__G__Meta_130_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassName",1175,G__G__Meta_130_0_11, 117, G__get_linked_tagnum(&G__G__MetaLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassVersion",1532,G__G__Meta_130_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRules",811,G__G__Meta_130_0_13, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPersistentRules",1884,G__G__Meta_130_0_14, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveRule",1030,G__G__Meta_130_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'ROOT::TSchemaRule' - 0 - rule", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveRules",1145,G__G__Meta_130_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - rules", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClass",802,G__G__Meta_130_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cls", (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("AsString",811,G__G__Meta_130_0_19, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_130_0_20, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ROOT::TSchemaRuleSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_130_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRuleSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_130_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ROOT::TSchemaRuleSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_130_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ROOT::TSchemaRuleSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_130_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_130_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRuleSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_130_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaRuleSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_130_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRuleSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_130_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaRuleSet::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSchemaRuleSet", 1385, G__G__Meta_130_0_32, (int) ('i'), G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet), -1, 0, 1, 1, 1, 0, "u 'ROOT::TSchemaRuleSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSchemaRuleSet", 1511, G__G__Meta_130_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_130_0_34, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet), -1, 1, 1, 1, 1, 0, "u 'ROOT::TSchemaRuleSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTClassGenerator(void) {
   /* TClassGenerator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassGenerator));
   G__memfunc_setup("GetClass",790,G__G__Meta_148_0_2, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 2, 1, 1, 0, 
"C - - 10 - classname g - 'Bool_t' 0 - load", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetClass",790,G__G__Meta_148_0_3, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 2, 1, 1, 0, 
"u 'type_info' - 11 - typeinfo g - 'Bool_t' 0 - load", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetClass",790,G__G__Meta_148_0_4, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 3, 1, 1, 0, 
"C - - 10 - classname g - 'Bool_t' 0 - load "
"g - 'Bool_t' 0 - silent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,G__G__Meta_148_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 3, 1, 1, 0, 
"u 'type_info' - 11 - typeinfo g - 'Bool_t' 0 - load "
"g - 'Bool_t' 0 - silent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_148_0_6, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TClassGenerator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_148_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassGenerator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_148_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TClassGenerator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_148_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClassGenerator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_148_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__Meta_148_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassGenerator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_148_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClassGenerator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_148_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassGenerator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_148_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClassGenerator::DeclFileLine) ), 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_148_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TClassGenerator), -1, 1, 1, 1, 1, 0, "u 'TClassGenerator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTClassMenuItem(void) {
   /* TClassMenuItem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem));
   G__memfunc_setup("TClassMenuItem",1390,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem), -1, 0, 1, 1, 2, 0, "u 'TClassMenuItem' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem), -1, 1, 1, 1, 2, 0, "u 'TClassMenuItem' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassMenuItem",1390,G__G__Meta_149_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClassMenuItem",1390,G__G__Meta_149_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TClassMenuItem), -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - type U 'TClass' - 0 - parent "
"C - - 10 '\"\"' title C - - 10 '\"\"' functionname "
"U 'TObject' - 0 '0' obj C - - 10 '\"\"' args "
"i - 'Int_t' 0 '-1' selfobjposition g - 'Bool_t' 0 'kFALSE' self", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunctionName",1511,G__G__Meta_149_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArgs",685,G__G__Meta_149_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCalledObject",1468,G__G__Meta_149_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Meta_149_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelfObjectPos",1587,G__G__Meta_149_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCallSelf",962,G__G__Meta_149_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSeparator",1133,G__G__Meta_149_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsStandardList",1417,G__G__Meta_149_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsToggle",798,G__G__Meta_149_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetType",718,G__G__Meta_149_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Meta_149_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelf",694,G__G__Meta_149_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - self", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetToggle",910,G__G__Meta_149_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' toggle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCall",680,G__G__Meta_149_0_19, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 - method "
"C - - 10 '\"\"' args i - 'Int_t' 0 '0' selfobjposition", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_149_0_20, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TClassMenuItem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_149_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassMenuItem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_149_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TClassMenuItem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_149_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClassMenuItem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_149_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_149_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassMenuItem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_149_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClassMenuItem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_149_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassMenuItem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_149_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClassMenuItem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TClassMenuItem", 1516, G__G__Meta_149_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDataType(void) {
   /* TDataType */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TDataType));
   G__memfunc_setup("CheckInfo",874,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetType",718,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataType",880,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TDataType), -1, 0, 1, 1, 2, 0, "u 'TDataType' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TDataType), -1, 1, 1, 1, 2, 0, "u 'TDataType' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataType",880,G__G__Meta_152_0_5, 105, G__get_linked_tagnum(&G__G__MetaLN_TDataType), -1, 0, 1, 1, 1, 0, "Y - 'TypedefInfo_t' 0 '0' info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataType",880,G__G__Meta_152_0_6, 105, G__get_linked_tagnum(&G__G__MetaLN_TDataType), -1, 0, 1, 1, 1, 0, "C - - 10 - typenam", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Size",411,G__G__Meta_152_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Meta_152_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,G__G__Meta_152_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFullTypeName",1494,G__G__Meta_152_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Meta_152_0_11, 67, -1, -1, 0, 1, 1, 1, 9, "Y - - 0 - buf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,G__G__Meta_152_0_13, 67, -1, -1, 0, 1, 3, 1, 1, "i 'EDataType' - 0 - type", (char*)NULL, (void*) G__func2void( (const char* (*)(EDataType))(&TDataType::GetTypeName) ), 0);
   G__memfunc_setup("GetType",706,G__G__Meta_152_0_14, 105, G__get_linked_tagnum(&G__G__MetaLN_EDataType), -1, 0, 1, 3, 1, 0, "u 'type_info' - 11 - typeinfo", (char*)NULL, (void*) G__func2void( (EDataType (*)(const type_info&))(&TDataType::GetType) ), 0);
   G__memfunc_setup("Class",502,G__G__Meta_152_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDataType::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_152_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataType::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_152_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDataType::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_152_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDataType::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_152_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__Meta_152_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataType::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_152_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataType::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_152_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataType::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_152_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataType::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDataType", 1006, G__G__Meta_152_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFunction(void) {
   /* TFunction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TFunction));
   G__memfunc_setup("CreateSignature",1542,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TFunction",922,G__G__Meta_156_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_TFunction), -1, 0, 1, 1, 1, 0, "Y - 'MethodInfo_t' 0 '0' info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFunction",922,G__G__Meta_156_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TFunction), -1, 0, 1, 1, 1, 0, "u 'TFunction' - 11 - orig", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_156_0_4, 117, G__get_linked_tagnum(&G__G__MetaLN_TFunction), -1, 1, 1, 1, 1, 0, "u 'TFunction' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMangledName",1369,G__G__Meta_156_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrototype",1270,G__G__Meta_156_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSignature",1234,G__G__Meta_156_0_8, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReturnTypeName",1731,G__G__Meta_156_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMethodArgs",1887,G__G__Meta_156_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNargs",795,G__G__Meta_156_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNargsOpt",1102,G__G__Meta_156_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InterfaceMethod",1522,G__G__Meta_156_0_13, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_156_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFunction::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_156_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunction::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_156_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFunction::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_156_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFunction::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_156_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__Meta_156_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunction::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_156_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFunction::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_156_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunction::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_156_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFunction::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFunction", 1048, G__G__Meta_156_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGlobal(void) {
   /* TGlobal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TGlobal));
   G__memfunc_setup("TGlobal",677,G__G__Meta_157_0_1, 105, G__get_linked_tagnum(&G__G__MetaLN_TGlobal), -1, 0, 1, 1, 1, 0, "Y - 'DataMemberInfo_t' 0 '0' info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGlobal",677,G__G__Meta_157_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_TGlobal), -1, 0, 1, 1, 1, 0, "u 'TGlobal' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_157_0_3, 117, G__get_linked_tagnum(&G__G__MetaLN_TGlobal), -1, 1, 1, 1, 1, 0, "u 'TGlobal' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArrayDim",1081,G__G__Meta_157_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxIndex",1086,G__G__Meta_157_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAddress",998,G__G__Meta_157_0_6, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,G__G__Meta_157_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFullTypeName",1494,G__G__Meta_157_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_157_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGlobal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_157_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGlobal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_157_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGlobal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_157_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGlobal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_157_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_157_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGlobal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_157_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGlobal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_157_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGlobal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_157_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGlobal::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGlobal", 803, G__G__Meta_157_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTInterpreter(void) {
   /* TInterpreter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TInterpreter));
   G__memfunc_setup("Execute",723,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TMethod' - 0 - method U 'TObjArray' - 0 - params "
"I - - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddIncludePath",1370,G__G__Meta_160_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AutoLoad",793,G__G__Meta_160_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - classname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ClearFileBusy",1290,G__G__Meta_160_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ClearStack",989,G__G__Meta_160_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "Delete existing temporary values", (void*) NULL, 3);
   G__memfunc_setup("EnableAutoLoading",1694,G__G__Meta_160_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EndOfLineAction",1458,G__G__Meta_160_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetExitCode",1077,G__G__Meta_160_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMapfile",990,G__G__Meta_160_0_11, 85, G__get_linked_tagnum(&G__G__MetaLN_TEnv), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMore",691,G__G__Meta_160_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GenerateDictionary",1857,G__G__Meta_160_0_13, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - classes C - - 10 '0' includes "
"C - - 10 '0' options", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPrompt",930,G__G__Meta_160_0_14, 67, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSharedLibs",1281,G__G__Meta_160_0_15, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetClassSharedLibs",1783,G__G__Meta_160_0_16, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - cls", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSharedLibDeps",1562,G__G__Meta_160_0_17, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - lib", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetIncludePath",1393,G__G__Meta_160_0_18, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSTLIncludePath",1636,G__G__Meta_160_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRootMapFiles",1493,G__G__Meta_160_0_20, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InitializeDictionaries",2288,G__G__Meta_160_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsLoaded",773,G__G__Meta_160_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - filename", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Load",384,G__G__Meta_160_0_23, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filenam g - 'Bool_t' 0 'kFALSE' system", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("LoadMacro",882,G__G__Meta_160_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename I 'TInterpreter::EErrorCode' - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("LoadLibraryMap",1395,G__G__Meta_160_0_25, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' rootmapfile", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RescanLibraryMap",1615,G__G__Meta_160_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReloadAllSharedLibraryMaps",2605,G__G__Meta_160_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UnloadAllSharedLibraryMaps",2617,G__G__Meta_160_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UnloadLibraryMap",1622,G__G__Meta_160_0_29, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - library", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessLine",1127,G__G__Meta_160_0_30, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - line I 'TInterpreter::EErrorCode' - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessLineSynch",1644,G__G__Meta_160_0_31, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - line I 'TInterpreter::EErrorCode' - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintIntro",1049,G__G__Meta_160_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGetline",1012,G__G__Meta_160_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"1 - 'char *(*)(const char* prompt)' 0 - getlineFunc 1 - 'void (*)(char* line)' 0 - histaddFunc", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Reset",515,G__G__Meta_160_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResetAll",796,G__G__Meta_160_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResetGlobals",1223,G__G__Meta_160_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RewindDictionary",1663,G__G__Meta_160_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeleteGlobal",1188,G__G__Meta_160_0_38, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "Y - - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SaveContext",1140,G__G__Meta_160_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SaveGlobalsContext",1848,G__G__Meta_160_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UpdateListOfGlobals",1912,G__G__Meta_160_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UpdateListOfGlobalFunctions",2750,G__G__Meta_160_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UpdateListOfTypes",1737,G__G__Meta_160_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetClassInfo",1198,G__G__Meta_160_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 0 - cl g - 'Bool_t' 0 'kFALSE' reload", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckClassInfo",1376,G__G__Meta_160_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' autoload", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Calc",371,G__G__Meta_160_0_46, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - line I 'TInterpreter::EErrorCode' - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateListOfBaseClasses",2286,G__G__Meta_160_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateListOfDataMembers",2282,G__G__Meta_160_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateListOfMethods",1913,G__G__Meta_160_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateListOfMethodArgs",2195,G__G__Meta_160_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFunction' - 0 - m", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UpdateListOfMethods",1928,G__G__Meta_160_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMangledName",1369,G__G__Meta_160_0_52, 117, G__get_linked_tagnum(&G__G__MetaLN_TString), -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - params", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMangledNameWithPrototype",2763,G__G__Meta_160_0_53, 117, G__get_linked_tagnum(&G__G__MetaLN_TString), -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - proto", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetInterpreterTypeName",2263,G__G__Meta_160_0_54, 67, -1, -1, 0, 2, 1, 1, 1, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' full", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetInterfaceMethod",1810,G__G__Meta_160_0_55, 89, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - params", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetInterfaceMethodWithPrototype",3204,G__G__Meta_160_0_56, 89, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - method "
"C - - 10 - proto", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Execute",723,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - function C - - 10 - params "
"I - - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Execute",723,G__G__Meta_160_0_58, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TObject' - 0 - obj U 'TClass' - 0 - cl "
"C - - 10 - method C - - 10 - params "
"I - - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Execute",723,G__G__Meta_160_0_59, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TObject' - 0 - obj U 'TClass' - 0 - cl "
"U 'TMethod' - 0 - method U 'TObjArray' - 0 - params "
"I - - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExecuteMacro",1221,G__G__Meta_160_0_60, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename I 'TInterpreter::EErrorCode' - 0 '0' error", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsErrorMessagesEnabled",2217,G__G__Meta_160_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetErrorMessages",1646,G__G__Meta_160_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsProcessLineLocked",1909,G__G__Meta_160_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetProcessLineLock",1820,G__G__Meta_160_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' lock", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TypeName",803,G__G__Meta_160_0_65, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DisplayClass",1228,G__G__Meta_160_0_66, 105, -1, -1, 0, 4, 1, 1, 8, 
"E - - 0 - - C - - 0 - - "
"i - - 0 - - i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisplayIncludePath",1831,G__G__Meta_160_0_67, 105, -1, -1, 0, 1, 1, 1, 8, "E - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindSym",698,G__G__Meta_160_0_68, 89, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenericError",1223,G__G__Meta_160_0_69, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExecByteCode",1460,G__G__Meta_160_0_70, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Getgvp",621,G__G__Meta_160_0_71, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Getp2f2funcname",1447,G__G__Meta_160_0_72, 67, -1, -1, 0, 1, 1, 1, 9, "Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTopLevelMacroName",1982,G__G__Meta_160_0_73, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentMacroName",1910,G__G__Meta_160_0_74, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSecurityError",1666,G__G__Meta_160_0_75, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadFile",768,G__G__Meta_160_0_76, 105, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadText",805,G__G__Meta_160_0_77, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapCppName",962,G__G__Meta_160_0_78, 67, -1, -1, 0, 1, 1, 1, 9, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlloclockfunc",1644,G__G__Meta_160_0_79, 121, -1, -1, 0, 1, 1, 1, 8, "1 - 'void (*)()' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAllocunlockfunc",1871,G__G__Meta_160_0_80, 121, -1, -1, 0, 1, 1, 1, 8, "1 - 'void (*)()' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClassAutoloading",1945,G__G__Meta_160_0_81, 105, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetErrmsgcallback",1737,G__G__Meta_160_0_82, 121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setgvp",633,G__G__Meta_160_0_83, 121, -1, -1, 0, 1, 1, 1, 8, "l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRTLD_NOW",949,G__G__Meta_160_0_84, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRTLD_LAZY",1025,G__G__Meta_160_0_85, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTempLevel",1210,G__G__Meta_160_0_86, 121, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnloadFile",995,G__G__Meta_160_0_87, 105, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_Delete",1466,G__G__Meta_160_0_88, 121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_Exec",1260,G__G__Meta_160_0_89, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_ExecInt",1559,G__G__Meta_160_0_90, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_ExecInt64",1665,G__G__Meta_160_0_91, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_ExecDouble",1863,G__G__Meta_160_0_92, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_Factory",1599,G__G__Meta_160_0_93, 89, -1, G__defined_typename("CallFunc_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_FactoryCopy",2010,G__G__Meta_160_0_94, 89, -1, G__defined_typename("CallFunc_t"), 0, 1, 1, 1, 8, "Y - 'CallFunc_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_FactoryMethod",2208,G__G__Meta_160_0_95, 89, -1, G__defined_typename("MethodInfo_t"), 0, 1, 1, 1, 8, "Y - 'CallFunc_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_Init",1275,G__G__Meta_160_0_96, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'CallFunc_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_IsValid",1555,G__G__Meta_160_0_97, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'CallFunc_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_ResetArg",1668,G__G__Meta_160_0_98, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'CallFunc_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetArg",1453,G__G__Meta_160_0_99, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetArg",1453,G__G__Meta_160_0_100, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetArg",1453,G__G__Meta_160_0_101, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetArg",1453,G__G__Meta_160_0_102, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - m - 'ULong64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetArgArray",1964,G__G__Meta_160_0_103, 121, -1, -1, 0, 3, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - L - 'Long_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetArgs",1568,G__G__Meta_160_0_104, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetFunc",1567,G__G__Meta_160_0_105, 121, -1, -1, 0, 5, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - 'ClassInfo_t' 0 - - "
"C - - 10 - - C - - 10 - - "
"L - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetFunc",1567,G__G__Meta_160_0_106, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CallFunc_SetFuncProto",2099,G__G__Meta_160_0_107, 121, -1, -1, 0, 5, 1, 1, 8, 
"Y - 'CallFunc_t' 0 - - Y - 'ClassInfo_t' 0 - - "
"C - - 10 - - C - - 10 - - "
"L - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_ClassProperty",2364,G__G__Meta_160_0_108, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Delete",1588,G__G__Meta_160_0_109, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Delete",1588,G__G__Meta_160_0_110, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_DeleteArray",2099,G__G__Meta_160_0_111, 121, -1, -1, 0, 3, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - Y - - 0 - - "
"g - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Destruct",1839,G__G__Meta_160_0_112, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Factory",1721,G__G__Meta_160_0_113, 89, -1, G__defined_typename("ClassInfo_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Factory",1721,G__G__Meta_160_0_114, 89, -1, G__defined_typename("ClassInfo_t"), 0, 1, 1, 1, 8, "U 'G__value' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Factory",1721,G__G__Meta_160_0_115, 89, -1, G__defined_typename("ClassInfo_t"), 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Factory",1721,G__G__Meta_160_0_116, 89, -1, G__defined_typename("ClassInfo_t"), 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_GetMethodNArg",2250,G__G__Meta_160_0_117, 105, -1, -1, 0, 3, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - C - - 10 - - "
"C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_HasDefaultConstructor",3176,G__G__Meta_160_0_118, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_HasMethod",1886,G__G__Meta_160_0_119, 103, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Init",1397,G__G__Meta_160_0_120, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Init",1397,G__G__Meta_160_0_121, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_IsBase",1560,G__G__Meta_160_0_122, 103, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_IsEnum",1586,G__G__Meta_160_0_123, 103, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_IsLoaded",1766,G__G__Meta_160_0_124, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_IsValid",1677,G__G__Meta_160_0_125, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_IsValidMethod",2286,G__G__Meta_160_0_126, 103, -1, -1, 0, 4, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - C - - 10 - - "
"C - - 10 - - L - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Next",1408,G__G__Meta_160_0_127, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_New",1291,G__G__Meta_160_0_128, 89, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_New",1291,G__G__Meta_160_0_129, 89, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_New",1291,G__G__Meta_160_0_130, 89, -1, -1, 0, 3, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - i - - 0 - - "
"Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_New",1291,G__G__Meta_160_0_131, 89, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'ClassInfo_t' 0 - - Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Property",1862,G__G__Meta_160_0_132, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_RootFlag",1791,G__G__Meta_160_0_133, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Size",1404,G__G__Meta_160_0_134, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Tagnum",1613,G__G__Meta_160_0_135, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_FileName",1762,G__G__Meta_160_0_136, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_FullName",1781,G__G__Meta_160_0_137, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Name",1378,G__G__Meta_160_0_138, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_Title",1507,G__G__Meta_160_0_139, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassInfo_TmpltName",1907,G__G__Meta_160_0_140, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Delete",1967,G__G__Meta_160_0_141, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Factory",2100,G__G__Meta_160_0_142, 89, -1, G__defined_typename("BaseClassInfo_t"), 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Next",1787,G__G__Meta_160_0_143, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Next",1787,G__G__Meta_160_0_144, 105, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'BaseClassInfo_t' 0 - - i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Offset",1987,G__G__Meta_160_0_145, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Property",2241,G__G__Meta_160_0_146, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Tagnum",1992,G__G__Meta_160_0_147, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_FullName",2160,G__G__Meta_160_0_148, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_Name",1757,G__G__Meta_160_0_149, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseClassInfo_TmpltName",2286,G__G__Meta_160_0_150, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'BaseClassInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_ArrayDim",2262,G__G__Meta_160_0_151, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Delete",2064,G__G__Meta_160_0_152, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Factory",2197,G__G__Meta_160_0_153, 89, -1, G__defined_typename("DataMemberInfo_t"), 0, 1, 1, 1, 8, "Y - 'ClassInfo_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_FactoryCopy",2608,G__G__Meta_160_0_154, 89, -1, G__defined_typename("DataMemberInfo_t"), 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_IsValid",2153,G__G__Meta_160_0_155, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_MaxIndex",2267,G__G__Meta_160_0_156, 105, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'DataMemberInfo_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Next",1884,G__G__Meta_160_0_157, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Offset",2084,G__G__Meta_160_0_158, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Property",2338,G__G__Meta_160_0_159, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_TypeProperty",2756,G__G__Meta_160_0_160, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_TypeSize",2298,G__G__Meta_160_0_161, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_TypeName",2272,G__G__Meta_160_0_162, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_TypeTrueName",2688,G__G__Meta_160_0_163, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Name",1854,G__G__Meta_160_0_164, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_Title",1983,G__G__Meta_160_0_165, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataMemberInfo_ValidArrayIndex",2980,G__G__Meta_160_0_166, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'DataMemberInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_CreateSignature",2642,G__G__Meta_160_0_167, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'MethodInfo_t' 0 - - u 'TString' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Delete",1695,G__G__Meta_160_0_168, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Factory",1828,G__G__Meta_160_0_169, 89, -1, G__defined_typename("MethodInfo_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_FactoryCopy",2239,G__G__Meta_160_0_170, 89, -1, G__defined_typename("MethodInfo_t"), 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_InterfaceMethod",2622,G__G__Meta_160_0_171, 89, -1, G__defined_typename("MethodInfo_t"), 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_IsValid",1784,G__G__Meta_160_0_172, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_NArg",1460,G__G__Meta_160_0_173, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_NDefaultArg",2169,G__G__Meta_160_0_174, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Next",1515,G__G__Meta_160_0_175, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Property",1969,G__G__Meta_160_0_176, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Type",1518,G__G__Meta_160_0_177, 89, -1, G__defined_typename("TypeInfo_t"), 0, 1, 1, 1, 8, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_GetMangledName",2469,G__G__Meta_160_0_178, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_GetPrototype",2370,G__G__Meta_160_0_179, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Name",1485,G__G__Meta_160_0_180, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_TypeName",1903,G__G__Meta_160_0_181, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodInfo_Title",1614,G__G__Meta_160_0_182, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_Delete",1977,G__G__Meta_160_0_183, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_Factory",2110,G__G__Meta_160_0_184, 89, -1, G__defined_typename("MethodArgInfo_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_FactoryCopy",2521,G__G__Meta_160_0_185, 89, -1, G__defined_typename("MethodArgInfo_t"), 0, 1, 1, 1, 8, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_IsValid",2066,G__G__Meta_160_0_186, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_Next",1797,G__G__Meta_160_0_187, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_Property",2251,G__G__Meta_160_0_188, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_DefaultValue",2600,G__G__Meta_160_0_189, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_Name",1767,G__G__Meta_160_0_190, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MethodArgInfo_TypeName",2185,G__G__Meta_160_0_191, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'MethodArgInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Delete",1504,G__G__Meta_160_0_192, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Factory",1637,G__G__Meta_160_0_193, 89, -1, G__defined_typename("TypeInfo_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Factory",1637,G__G__Meta_160_0_194, 89, -1, G__defined_typename("TypeInfo_t"), 0, 1, 1, 1, 8, "U 'G__value' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_FactoryCopy",2048,G__G__Meta_160_0_195, 89, -1, G__defined_typename("TypeInfo_t"), 0, 1, 1, 1, 8, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Init",1313,G__G__Meta_160_0_196, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'TypeInfo_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_IsValid",1593,G__G__Meta_160_0_197, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Name",1294,G__G__Meta_160_0_198, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Property",1778,G__G__Meta_160_0_199, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_RefType",1612,G__G__Meta_160_0_200, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_Size",1320,G__G__Meta_160_0_201, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypeInfo_TrueName",1710,G__G__Meta_160_0_202, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'TypeInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Delete",1807,G__G__Meta_160_0_203, 121, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Factory",1940,G__G__Meta_160_0_204, 89, -1, G__defined_typename("TypedefInfo_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_FactoryCopy",2351,G__G__Meta_160_0_205, 89, -1, G__defined_typename("TypedefInfo_t"), 0, 1, 1, 1, 8, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Init",1616,G__G__Meta_160_0_206, 121, -1, -1, 0, 2, 1, 1, 8, 
"Y - 'TypedefInfo_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_IsValid",1896,G__G__Meta_160_0_207, 103, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Property",2081,G__G__Meta_160_0_208, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Size",1623,G__G__Meta_160_0_209, 105, -1, -1, 0, 1, 1, 1, 8, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_TrueName",2013,G__G__Meta_160_0_210, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Name",1597,G__G__Meta_160_0_211, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TypedefInfo_Title",1726,G__G__Meta_160_0_212, 67, -1, -1, 0, 1, 1, 1, 9, "Y - 'TypedefInfo_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Instance",821,G__G__Meta_160_0_213, 85, G__get_linked_tagnum(&G__G__MetaLN_TInterpreter), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TInterpreter*& (*)())(&TInterpreter::Instance) ), 0);
   G__memfunc_setup("Class",502,G__G__Meta_160_0_214, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TInterpreter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_160_0_215, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TInterpreter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_160_0_216, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TInterpreter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_160_0_217, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TInterpreter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_160_0_221, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_160_0_222, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TInterpreter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_160_0_223, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TInterpreter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_160_0_224, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TInterpreter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_160_0_225, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TInterpreter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TInterpreter", 1382, G__G__Meta_160_0_226, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_160_0_227, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TInterpreter), -1, 1, 1, 1, 1, 0, "u 'TInterpreter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTIsAProxy(void) {
   /* TIsAProxy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy));
   G__memfunc_setup("TIsAProxy",883,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy), -1, 0, 1, 1, 2, 0, "u 'TIsAProxy' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy), -1, 1, 1, 1, 2, 0, "u 'TIsAProxy' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIsAProxy",883,G__G__Meta_162_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TIsAProxy), -1, 0, 2, 1, 1, 0, 
"u 'type_info' - 11 - typ Y - - 0 '0' ctxt", (char*)NULL, (void*) NULL, 0);
   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("operator()",957,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 1, 1, 1, 0, "Y - - 10 - obj", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~TIsAProxy", 1009, G__G__Meta_162_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMethodArg(void) {
   /* TMethodArg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TMethodArg));
   G__memfunc_setup("TMethodArg",975,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodArg), -1, 0, 1, 1, 4, 0, "u 'TMethodArg' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TMethodArg), -1, 1, 1, 1, 4, 0, "u 'TMethodArg' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TMethodArg",975,G__G__Meta_163_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TMethodArg), -1, 0, 2, 1, 1, 0, 
"Y - 'MethodArgInfo_t' 0 '0' info U 'TFunction' - 0 '0' method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefault",997,G__G__Meta_163_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__Meta_163_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TFunction), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,G__G__Meta_163_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFullTypeName",1494,G__G__Meta_163_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Property",869,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDataMember",1266,G__G__Meta_163_0_9, 85, G__get_linked_tagnum(&G__G__MetaLN_TDataMember), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,G__G__Meta_163_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_163_0_11, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMethodArg::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_163_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodArg::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_163_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMethodArg::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_163_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMethodArg::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_163_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__Meta_163_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodArg::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_163_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethodArg::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_163_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodArg::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_163_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethodArg::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMethodArg", 1101, G__G__Meta_163_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLTSchemaRule(void) {
   /* ROOT::TSchemaRule */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule));
   G__memfunc_setup("TSchemaRule",1085,G__G__Meta_168_0_1, 105, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSchemaRule",1085,G__G__Meta_168_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule), -1, 0, 1, 1, 1, 0, "u 'ROOT::TSchemaRule' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_168_0_3, 117, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule), -1, 1, 1, 1, 1, 0, "u 'ROOT::TSchemaRule' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Meta_168_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'ROOT::TSchemaRule' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFromRule",1112,G__G__Meta_168_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - rule", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersion",1030,G__G__Meta_168_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVersion",1042,G__G__Meta_168_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestVersion",1158,G__G__Meta_168_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetChecksum",1119,G__G__Meta_168_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestChecksum",1235,G__G__Meta_168_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSourceClass",1427,G__G__Meta_168_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSourceClass",1415,G__G__Meta_168_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTargetClass",1417,G__G__Meta_168_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargetClass",1405,G__G__Meta_168_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTarget",915,G__G__Meta_168_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTarget",903,G__G__Meta_168_0_17, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargetString",1534,G__G__Meta_168_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSource",925,G__G__Meta_168_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSource",913,G__G__Meta_168_0_20, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmbed",777,G__G__Meta_168_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - embed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmbed",765,G__G__Meta_168_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAliasRule",1086,G__G__Meta_168_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRenameRule",1196,G__G__Meta_168_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Meta_168_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCode",679,G__G__Meta_168_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCode",667,G__G__Meta_168_0_27, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttributes",1363,G__G__Meta_168_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - attributes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttributes",1351,G__G__Meta_168_0_29, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasTarget",899,G__G__Meta_168_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TString' - 11 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasSource",909,G__G__Meta_168_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TString' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadFunctionPointer",2255,G__G__Meta_168_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::TSchemaRule::ReadFuncPtr_t' 0 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadFunctionPointer",2243,G__G__Meta_168_0_33, 89, -1, G__defined_typename("ROOT::TSchemaRule::ReadFuncPtr_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadRawFunctionPointer",2553,G__G__Meta_168_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::TSchemaRule::ReadRawFuncPtr_t' 0 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadRawFunctionPointer",2541,G__G__Meta_168_0_35, 89, -1, G__defined_typename("ROOT::TSchemaRule::ReadRawFuncPtr_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInclude",1008,G__G__Meta_168_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - include", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,G__G__Meta_168_0_37, 85, G__get_linked_tagnum(&G__G__MetaLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRuleType",1126,G__G__Meta_168_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::TSchemaRule::RuleType_t' 'ROOT::TSchemaRule::RuleType_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleType",1114,G__G__Meta_168_0_39, 105, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t), G__defined_typename("ROOT::TSchemaRule::RuleType_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Conflicts",933,G__G__Meta_168_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'ROOT::TSchemaRule' - 10 - rule", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Meta_168_0_41, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TString' - 1 - out C - - 10 '\"\"' options", (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("Class",502,G__G__Meta_168_0_43, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ROOT::TSchemaRule::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_168_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRule::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_168_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ROOT::TSchemaRule::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_168_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ROOT::TSchemaRule::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_168_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_168_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRule::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_168_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaRule::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_168_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRule::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_168_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaRule::DeclFileLine) ), 0);
   G__memfunc_setup("ProcessVersion",1477,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "u 'TString' - 11 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessChecksum",1554,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "u 'TString' - 11 - checksum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessList",1147,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"U 'TObjArray' - 0 - array u 'TString' - 11 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessDeclaration",1861,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"U 'TObjArray' - 0 - array u 'TString' - 11 - list", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSchemaRule", 1211, G__G__Meta_168_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLTSchemaRulecLcLTSources(void) {
   /* ROOT::TSchemaRule::TSources */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources));
   G__memfunc_setup("TSources",824,G__G__Meta_169_0_1, 105, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources), -1, 0, 3, 1, 1, 0, 
"C - - 10 '0' name C - - 10 '0' title "
"C - - 10 '0' dims", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDimensions",1337,G__G__Meta_169_0_2, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_169_0_3, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ROOT::TSchemaRule::TSources::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_169_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRule::TSources::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_169_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ROOT::TSchemaRule::TSources::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_169_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ROOT::TSchemaRule::TSources::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_169_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_169_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRule::TSources::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_169_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaRule::TSources::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_169_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaRule::TSources::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_169_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaRule::TSources::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSources", 824, G__G__Meta_169_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources), -1, 0, 1, 1, 1, 0, "u 'ROOT::TSchemaRule::TSources' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSources", 950, G__G__Meta_169_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_169_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources), -1, 1, 1, 1, 1, 0, "u 'ROOT::TSchemaRule::TSources' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR(void) {
   /* vector<pair<int,int>,allocator<pair<int,int> > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__memfunc_setup("at",213,G__G__Meta_173_0_1, 117, G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR), -1, 1, 1, 1, 1, 0, "h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Meta_173_0_2, 117, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Meta_173_0_3, 117, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Meta_173_0_4, 117, G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR), G__defined_typename("vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Meta_173_0_5, 117, G__get_linked_tagnum(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR), G__defined_typename("vector<pair<int,int>,allocator<pair<int,int> > >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Meta_173_0_6, 104, -1, G__defined_typename("vector<pair<int,int>,allocator<pair<int,int> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Meta_173_0_7, 104, -1, G__defined_typename("vector<pair<int,int>,allocator<pair<int,int> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Meta_173_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Meta_173_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - sz u 'pair<int,int>' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__G__Meta_173_0_10, 104, -1, G__defined_typename("vector<pair<int,int>,allocator<pair<int,int> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Meta_173_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Meta_173_0_12, 117, G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR), -1, 1, 1, 1, 1, 0, "h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<pair<int,int>,allocator<pair<int,int> > >",4484,G__G__Meta_173_0_13, 105, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<pair<int,int>,allocator<pair<int,int> > >",4484,G__G__Meta_173_0_14, 105, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - n u 'pair<int,int>' - 11 '(pair<int,int>)()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<pair<int,int>,allocator<pair<int,int> > >",4484,G__G__Meta_173_0_15, 105, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<pair<int,int>,allocator<pair<int,int> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<pair<int,int>,allocator<pair<int,int> > >",4484,G__G__Meta_173_0_16, 105, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' 'vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator' 10 - first u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' 'vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_173_0_17, 117, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<pair<int,int>,allocator<pair<int,int> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__G__Meta_173_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__G__Meta_173_0_19, 117, G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__G__Meta_173_0_20, 117, G__get_linked_tagnum(&G__G__MetaLN_pairlEintcOintgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Meta_173_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pair<int,int>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Meta_173_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<pair<int,int>,allocator<pair<int,int> > >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Meta_173_0_23, 117, G__get_linked_tagnum(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' - 0 - position u 'pair<int,int>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Meta_173_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' - 0 - position u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' 'vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator' 10 - first "
"u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' 'vector<pair<int,int>,allocator<pair<int,int> > >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Meta_173_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' - 0 - position h - 'vector<pair<int,int>,allocator<pair<int,int> > >::size_type' 0 - n "
"u 'pair<int,int>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__G__Meta_173_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Meta_173_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Meta_173_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' - 0 - first u 'vector<pair<int,int>,allocator<pair<int,int> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Meta_173_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<pair<int,int>,allocator<pair<int,int> > >", 4610, G__G__Meta_173_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLTSchemaMatch(void) {
   /* ROOT::TSchemaMatch */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaMatch));
   G__memfunc_setup("GetRuleWithSource",1733,G__G__Meta_180_0_1, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule), -1, 0, 1, 1, 1, 9, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleWithTarget",1723,G__G__Meta_180_0_2, 85, G__get_linked_tagnum(&G__G__MetaLN_ROOTcLcLTSchemaRule), -1, 0, 1, 1, 1, 9, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasRuleWithSource",1729,G__G__Meta_180_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"u 'TString' - 11 - name g - 'Bool_t' 0 - needingAlloc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasRuleWithTarget",1719,G__G__Meta_180_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"u 'TString' - 11 - name g - 'Bool_t' 0 - willset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_180_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ROOT::TSchemaMatch::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_180_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaMatch::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_180_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ROOT::TSchemaMatch::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_180_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ROOT::TSchemaMatch::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_180_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__Meta_180_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaMatch::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_180_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaMatch::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_180_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ROOT::TSchemaMatch::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_180_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ROOT::TSchemaMatch::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSchemaMatch", 1296, G__G__Meta_180_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerBasicType(void) {
   /* TStreamerBasicType */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType));
   G__memfunc_setup("TStreamerBasicType",1819,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType), -1, 0, 1, 1, 4, 0, "u 'TStreamerBasicType' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType), -1, 1, 1, 1, 4, 0, "u 'TStreamerBasicType' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerBasicType",1819,G__G__Meta_182_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerBasicType",1819,G__G__Meta_182_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicType), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset i - 'Int_t' 0 - dtype "
"C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCounter",1024,G__G__Meta_182_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_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("Class",502,G__G__Meta_182_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerBasicType::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_182_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBasicType::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_182_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerBasicType::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_182_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerBasicType::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_182_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__Meta_182_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBasicType::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_182_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerBasicType::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_182_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBasicType::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_182_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerBasicType::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerBasicType", 1945, G__G__Meta_182_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerBase(void) {
   /* TStreamerBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase));
   G__memfunc_setup("TStreamerBase",1298,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase), -1, 0, 1, 1, 4, 0, "u 'TStreamerBase' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase), -1, 1, 1, 1, 4, 0, "u 'TStreamerBase' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerBase",1298,G__G__Meta_185_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerBase",1298,G__G__Meta_185_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBase), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseVersion",1409,G__G__Meta_185_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassPointer",1527,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNewBaseClass",1467,G__G__Meta_185_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsBase",567,(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("ReadBuffer",982,G__G__Meta_185_0_14, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - b C - - 0 - pointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNewBaseClass",1479,G__G__Meta_185_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaseVersion",1421,G__G__Meta_185_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (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("WriteBuffer",1125,G__G__Meta_185_0_18, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - b C - - 0 - pointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_185_0_19, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_185_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_185_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_185_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_185_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_185_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_185_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_185_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_185_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerBase", 1424, G__G__Meta_185_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerBasicPointer(void) {
   /* TStreamerBasicPointer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer));
   G__memfunc_setup("TStreamerBasicPointer",2138,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer), -1, 0, 1, 1, 4, 0, "u 'TStreamerBasicPointer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer), -1, 1, 1, 1, 4, 0, "u 'TStreamerBasicPointer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerBasicPointer",2138,G__G__Meta_186_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerBasicPointer",2138,G__G__Meta_186_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerBasicPointer), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset i - 'Int_t' 0 - dtype "
"C - - 10 - countName C - - 10 - countClass "
"i - 'Int_t' 0 - version C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCountClass",1311,G__G__Meta_186_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCountName",1194,G__G__Meta_186_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCountVersion",1551,G__G__Meta_186_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCounter",1020,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsaPointer",1022,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetArrayDim",1093,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCountClass",1323,G__G__Meta_186_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - clname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCountName",1206,G__G__Meta_186_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCountVersion",1563,G__G__Meta_186_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - count", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_186_0_17, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerBasicPointer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_186_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBasicPointer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_186_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerBasicPointer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_186_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerBasicPointer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_186_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_186_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBasicPointer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_186_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerBasicPointer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_186_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerBasicPointer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_186_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerBasicPointer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerBasicPointer", 2264, G__G__Meta_186_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerLoop(void) {
   /* TStreamerLoop */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop));
   G__memfunc_setup("TStreamerLoop",1329,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop), -1, 0, 1, 1, 4, 0, "u 'TStreamerLoop' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop), -1, 1, 1, 1, 4, 0, "u 'TStreamerLoop' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerLoop",1329,G__G__Meta_187_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerLoop",1329,G__G__Meta_187_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerLoop), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - countName "
"C - - 10 - countClass i - 'Int_t' 0 - version "
"C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCountClass",1311,G__G__Meta_187_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCountName",1194,G__G__Meta_187_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCountVersion",1551,G__G__Meta_187_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsaPointer",1022,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCounter",1020,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCountClass",1323,G__G__Meta_187_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - clname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCountName",1206,G__G__Meta_187_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCountVersion",1563,G__G__Meta_187_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - count", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_187_0_17, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerLoop::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_187_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerLoop::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_187_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerLoop::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_187_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerLoop::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_187_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_187_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerLoop::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_187_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerLoop::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_187_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerLoop::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_187_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerLoop::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerLoop", 1455, G__G__Meta_187_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerObject(void) {
   /* TStreamerObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject));
   G__memfunc_setup("TStreamerObject",1518,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject), -1, 0, 1, 1, 4, 0, "u 'TStreamerObject' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject), -1, 1, 1, 1, 4, 0, "u 'TStreamerObject' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerObject",1518,G__G__Meta_188_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerObject",1518,G__G__Meta_188_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObject), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_188_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_188_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_188_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_188_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_188_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__Meta_188_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_188_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_188_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_188_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObject::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerObject", 1644, G__G__Meta_188_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerObjectAny(void) {
   /* TStreamerObjectAny */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny));
   G__memfunc_setup("TStreamerObjectAny",1814,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny), -1, 0, 1, 1, 4, 0, "u 'TStreamerObjectAny' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny), -1, 1, 1, 1, 4, 0, "u 'TStreamerObjectAny' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerObjectAny",1814,G__G__Meta_189_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerObjectAny",1814,G__G__Meta_189_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAny), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_189_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerObjectAny::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_189_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectAny::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_189_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerObjectAny::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_189_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerObjectAny::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_189_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__Meta_189_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectAny::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_189_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObjectAny::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_189_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectAny::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_189_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObjectAny::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerObjectAny", 1940, G__G__Meta_189_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerObjectPointer(void) {
   /* TStreamerObjectPointer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer));
   G__memfunc_setup("TStreamerObjectPointer",2255,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer), -1, 0, 1, 1, 4, 0, "u 'TStreamerObjectPointer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer), -1, 1, 1, 1, 4, 0, "u 'TStreamerObjectPointer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerObjectPointer",2255,G__G__Meta_190_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerObjectPointer",2255,G__G__Meta_190_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectPointer), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsaPointer",1022,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetArrayDim",1093,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_190_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerObjectPointer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_190_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectPointer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_190_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerObjectPointer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_190_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerObjectPointer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_190_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_190_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectPointer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_190_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObjectPointer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_190_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectPointer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_190_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObjectPointer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerObjectPointer", 2381, G__G__Meta_190_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerObjectAnyPointer(void) {
   /* TStreamerObjectAnyPointer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer));
   G__memfunc_setup("TStreamerObjectAnyPointer",2551,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer), -1, 0, 1, 1, 4, 0, "u 'TStreamerObjectAnyPointer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer), -1, 1, 1, 1, 4, 0, "u 'TStreamerObjectAnyPointer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerObjectAnyPointer",2551,G__G__Meta_191_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerObjectAnyPointer",2551,G__G__Meta_191_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerObjectAnyPointer), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsaPointer",1022,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetArrayDim",1093,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_191_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerObjectAnyPointer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_191_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectAnyPointer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_191_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerObjectAnyPointer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_191_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerObjectAnyPointer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_191_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_191_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectAnyPointer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_191_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObjectAnyPointer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_191_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerObjectAnyPointer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_191_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerObjectAnyPointer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerObjectAnyPointer", 2677, G__G__Meta_191_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerString(void) {
   /* TStreamerString */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerString));
   G__memfunc_setup("TStreamerString",1550,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerString), -1, 0, 1, 1, 4, 0, "u 'TStreamerString' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerString), -1, 1, 1, 1, 4, 0, "u 'TStreamerString' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerString",1550,G__G__Meta_192_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerString",1550,G__G__Meta_192_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerString), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("Class",502,G__G__Meta_192_0_7, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerString::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_192_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerString::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_192_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerString::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_192_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerString::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_192_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_192_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerString::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_192_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerString::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_192_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerString::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_192_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerString::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerString", 1676, G__G__Meta_192_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerSTL(void) {
   /* TStreamerSTL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL));
   G__memfunc_setup("TStreamerSTL",1162,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL), -1, 0, 1, 1, 4, 0, "u 'TStreamerSTL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL), -1, 1, 1, 1, 4, 0, "u 'TStreamerSTL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerSTL",1162,G__G__Meta_193_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerSTL",1162,G__G__Meta_193_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTL), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - typeName "
"C - - 10 - trueType g - 'Bool_t' 0 - dmPointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CannotSplit",1135,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsaPointer",1022,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsBase",567,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSTLtype",981,G__G__Meta_193_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCtype",805,G__G__Meta_193_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("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("SetSTLtype",993,G__G__Meta_193_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCtype",817,G__G__Meta_193_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStreamer",1135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMemberStreamer' - 0 - streamer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_193_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerSTL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_193_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerSTL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_193_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerSTL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_193_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerSTL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_193_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_193_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerSTL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_193_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerSTL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_193_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerSTL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_193_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerSTL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerSTL", 1288, G__G__Meta_193_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerSTLstring(void) {
   /* TStreamerSTLstring */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring));
   G__memfunc_setup("TStreamerSTLstring",1825,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring), -1, 0, 1, 1, 4, 0, "u 'TStreamerSTLstring' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring), -1, 1, 1, 1, 4, 0, "u 'TStreamerSTLstring' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerSTLstring",1825,G__G__Meta_195_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStreamerSTLstring",1825,G__G__Meta_195_0_4, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerSTLstring), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset C - - 10 - typeName "
"g - 'Bool_t' 0 - dmPointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInclude",996,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (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("Class",502,G__G__Meta_195_0_7, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerSTLstring::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_195_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerSTLstring::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_195_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerSTLstring::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_195_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerSTLstring::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_195_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_195_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerSTLstring::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_195_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerSTLstring::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_195_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerSTLstring::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_195_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerSTLstring::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerSTLstring", 1951, G__G__Meta_195_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStreamerArtificial(void) {
   /* TStreamerArtificial */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial));
   G__memfunc_setup("TStreamerArtificial",1935,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial), -1, 0, 1, 1, 4, 0, "u 'TStreamerArtificial' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial), -1, 1, 1, 1, 4, 0, "u 'TStreamerArtificial' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TStreamerArtificial",1935,G__G__Meta_196_0_3, 105, G__get_linked_tagnum(&G__G__MetaLN_TStreamerArtificial), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - offset i - 'Int_t' 0 - dtype "
"C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadFunc",1076,G__G__Meta_196_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::TSchemaRule::ReadFuncPtr_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadRawFunc",1374,G__G__Meta_196_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ROOT::TSchemaRule::ReadRawFuncPtr_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadFunc",1064,G__G__Meta_196_0_6, 89, -1, G__defined_typename("ROOT::TSchemaRule::ReadFuncPtr_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadRawFunc",1362,G__G__Meta_196_0_7, 89, -1, G__defined_typename("ROOT::TSchemaRule::ReadRawFuncPtr_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_196_0_8, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStreamerArtificial::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_196_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerArtificial::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_196_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStreamerArtificial::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_196_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStreamerArtificial::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_196_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__Meta_196_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerArtificial::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_196_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerArtificial::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_196_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStreamerArtificial::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_196_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStreamerArtificial::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStreamerArtificial", 2061, G__G__Meta_196_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTToggle(void) {
   /* TToggle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggle));
   G__memfunc_setup("TToggle",694,G__G__Meta_197_0_1, 105, G__get_linked_tagnum(&G__G__MetaLN_TToggle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToggledObject",1609,G__G__Meta_197_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj U 'TMethod' - 0 - anymethod", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetToggledVariable",1816,G__G__Meta_197_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 1 - var", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInitialized",1330,G__G__Meta_197_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetState",801,G__G__Meta_197_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,G__G__Meta_197_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Toggle",610,G__G__Meta_197_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOnValue",998,G__G__Meta_197_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - lon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOnValue",986,G__G__Meta_197_0_9, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOffValue",1092,G__G__Meta_197_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - lof", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOffValue",1080,G__G__Meta_197_0_11, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Meta_197_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValue",809,G__G__Meta_197_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGetter",907,G__G__Meta_197_0_14, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSetter",919,G__G__Meta_197_0_15, 85, G__get_linked_tagnum(&G__G__MetaLN_TMethodCall), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Meta_197_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TToggle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_197_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TToggle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_197_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TToggle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_197_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TToggle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_197_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_197_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TToggle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_197_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TToggle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_197_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TToggle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_197_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TToggle::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TToggle", 694, G__G__Meta_197_0_28, (int) ('i'), G__get_linked_tagnum(&G__G__MetaLN_TToggle), -1, 0, 1, 1, 1, 0, "u 'TToggle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TToggle", 820, G__G__Meta_197_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Meta_197_0_30, (int) ('u'), G__get_linked_tagnum(&G__G__MetaLN_TToggle), -1, 1, 1, 1, 1, 0, "u 'TToggle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTToggleGroup(void) {
   /* TToggleGroup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup));
   G__memfunc_setup("TToggleGroup",1219,G__G__Meta_201_0_1, 105, G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TToggleGroup",1219,G__G__Meta_201_0_2, 105, G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup), -1, 0, 1, 1, 1, 0, "u 'TToggleGroup' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Meta_201_0_3, 117, G__get_linked_tagnum(&G__G__MetaLN_TToggleGroup), -1, 1, 1, 1, 1, 0, "u 'TToggleGroup' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTogglesCount",1534,G__G__Meta_201_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__G__Meta_201_0_5, 85, G__get_linked_tagnum(&G__G__MetaLN_TToggle), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Meta_201_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TToggle' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Meta_201_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteAll",876,G__G__Meta_201_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,G__G__Meta_201_0_9, 85, G__get_linked_tagnum(&G__G__MetaLN_TToggle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,G__G__Meta_201_0_10, 85, G__get_linked_tagnum(&G__G__MetaLN_TToggle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IndexOf",685,G__G__Meta_201_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TToggle' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Meta_201_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TToggle' - 0 - t g - 'Bool_t' 0 '1' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertAt",810,G__G__Meta_201_0_13, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TToggle' - 0 - t i - 'Int_t' 0 - pos "
"g - 'Bool_t' 0 '1' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Meta_201_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Meta_201_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TToggle' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Meta_201_0_16, 85, G__get_linked_tagnum(&G__G__MetaLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TToggleGroup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Meta_201_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TToggleGroup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Meta_201_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TToggleGroup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Meta_201_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TToggleGroup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MetaLN_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__Meta_201_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Meta_201_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TToggleGroup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Meta_201_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TToggleGroup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Meta_201_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TToggleGroup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Meta_201_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TToggleGroup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TToggleGroup", 1345, G__G__Meta_201_0_28, (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__Meta() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsClass=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsStruct=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsUnion=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsEnum=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsNamespace=134217728",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsTypedef=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsFundamental=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsAbstract=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsVirtual=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsPureVirtual=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsPublic=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsProtected=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsPrivate=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsPointer=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsArray=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsStatic=16384",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsUsingVariable=536870912",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsDefault=32768",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsReference=65536",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsConstant=1048576",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsConstPointer=4194304",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MetaLN_EProperty),-1,-1,1,"kIsMethConst=268435456",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Meta() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Meta() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__MetaLN_type_info = { "type_info" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClassStreamer = { "TClassStreamer" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TMemberStreamer = { "TMemberStreamer" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TVirtualCollectionProxy = { "TVirtualCollectionProxy" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TVirtualIsAProxy = { "TVirtualIsAProxy" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTInitBehavior = { "ROOT::TInitBehavior" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTCollectionProxyInfo = { "ROOT::TCollectionProxyInfo" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TMethod = { "TMethod" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TVirtualStreamerInfo = { "TVirtualStreamerInfo" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerElement = { "TStreamerElement" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_EProperty = { "EProperty" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TDictionary = { "TDictionary" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TDictionarycLcLESTLType = { "TDictionary::ESTLType" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__MetaLN_TBaseClass = { "TBaseClass" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TDataMember = { "TDataMember" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClassRef = { "TClassRef" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TRealData = { "TRealData" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TMethodCall = { "TMethodCall" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TVirtualRefProxy = { "TVirtualRefProxy" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_THashTable = { "THashTable" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTSchemaRuleSet = { "ROOT::TSchemaRuleSet" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTMapTypeToTClass = { "ROOT::TMapTypeToTClass" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClasscLcLdA = { "TClass::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TClasscLcLENewType = { "TClass::ENewType" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClassGenerator = { "TClassGenerator" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClassMenuItem = { "TClassMenuItem" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType = { "TClassMenuItem::EClassMenuItemType" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TClassMenuItemcLcLdA = { "TClassMenuItem::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TDataType = { "TDataType" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TDataMembercLcLdA = { "TDataMember::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_EDataType = { "EDataType" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TFunction = { "TFunction" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TGlobal = { "TGlobal" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TEnv = { "TEnv" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_G__value = { "G__value" , 115 , -1 };
G__linked_taginfo G__G__MetaLN_TInterpreter = { "TInterpreter" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TInterpretercLcLEErrorCode = { "TInterpreter::EErrorCode" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TIsAProxy = { "TIsAProxy" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TMethodArg = { "TMethodArg" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TMethodCallcLcLEReturnType = { "TMethodCall::EReturnType" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_EMenuItemKind = { "EMenuItemKind" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TRealDatacLcLdA = { "TRealData::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTSchemaRule = { "ROOT::TSchemaRule" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources = { "ROOT::TSchemaRule::TSources" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t = { "ROOT::TSchemaRule::RuleType_t" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_pairlEintcOintgR = { "pair<int,int>" , 115 , -1 };
G__linked_taginfo G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR = { "vector<pair<int,int>,allocator<pair<int,int> > >" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator = { "vector<pair<int,int>,allocator<pair<int,int> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,int>,allocator<pair<int,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTSchemaMatch = { "ROOT::TSchemaMatch" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_ROOTcLcLTSchemaRuleSetcLcLEConsistencyCheck = { "ROOT::TSchemaRuleSet::EConsistencyCheck" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerBasicType = { "TStreamerBasicType" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerElementcLcLESTLtype = { "TStreamerElement::ESTLtype" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerElementcLcLdA = { "TStreamerElement::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerBase = { "TStreamerBase" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerBasicPointer = { "TStreamerBasicPointer" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerLoop = { "TStreamerLoop" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerObject = { "TStreamerObject" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerObjectAny = { "TStreamerObjectAny" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerObjectPointer = { "TStreamerObjectPointer" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerObjectAnyPointer = { "TStreamerObjectAnyPointer" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerString = { "TStreamerString" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerSTL = { "TStreamerSTL" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerSTLcLcLdA = { "TStreamerSTL::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerSTLstring = { "TStreamerSTLstring" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TStreamerArtificial = { "TStreamerArtificial" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TToggle = { "TToggle" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TOrdCollection = { "TOrdCollection" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TToggleGroup = { "TToggleGroup" , 99 , -1 };
G__linked_taginfo G__G__MetaLN_TVirtualStreamerInfocLcLdA = { "TVirtualStreamerInfo::$" , 101 , -1 };
G__linked_taginfo G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite = { "TVirtualStreamerInfo::EReadWrite" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Meta() {
  G__G__MetaLN_type_info.tagnum = -1 ;
  G__G__MetaLN_TClass.tagnum = -1 ;
  G__G__MetaLN_TBuffer.tagnum = -1 ;
  G__G__MetaLN_TMemberInspector.tagnum = -1 ;
  G__G__MetaLN_TObject.tagnum = -1 ;
  G__G__MetaLN_TNamed.tagnum = -1 ;
  G__G__MetaLN_TString.tagnum = -1 ;
  G__G__MetaLN_TClassStreamer.tagnum = -1 ;
  G__G__MetaLN_TMemberStreamer.tagnum = -1 ;
  G__G__MetaLN_TVirtualCollectionProxy.tagnum = -1 ;
  G__G__MetaLN_TVirtualIsAProxy.tagnum = -1 ;
  G__G__MetaLN_ROOT.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTInitBehavior.tagnum = -1 ;
  G__G__MetaLN_string.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTCollectionProxyInfo.tagnum = -1 ;
  G__G__MetaLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__MetaLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MetaLN_TList.tagnum = -1 ;
  G__G__MetaLN_TBrowser.tagnum = -1 ;
  G__G__MetaLN_TObjArray.tagnum = -1 ;
  G__G__MetaLN_TMethod.tagnum = -1 ;
  G__G__MetaLN_TVirtualStreamerInfo.tagnum = -1 ;
  G__G__MetaLN_TStreamerElement.tagnum = -1 ;
  G__G__MetaLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__MetaLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MetaLN_EProperty.tagnum = -1 ;
  G__G__MetaLN_TDictionary.tagnum = -1 ;
  G__G__MetaLN_TDictionarycLcLESTLType.tagnum = -1 ;
  G__G__MetaLN_TCollection.tagnum = -1 ;
  G__G__MetaLN_TSeqCollection.tagnum = -1 ;
  G__G__MetaLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__MetaLN_TBaseClass.tagnum = -1 ;
  G__G__MetaLN_TDataMember.tagnum = -1 ;
  G__G__MetaLN_TClassRef.tagnum = -1 ;
  G__G__MetaLN_TRealData.tagnum = -1 ;
  G__G__MetaLN_TMethodCall.tagnum = -1 ;
  G__G__MetaLN_TVirtualRefProxy.tagnum = -1 ;
  G__G__MetaLN_THashTable.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTSchemaRuleSet.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTMapTypeToTClass.tagnum = -1 ;
  G__G__MetaLN_TClasscLcLdA.tagnum = -1 ;
  G__G__MetaLN_TClasscLcLENewType.tagnum = -1 ;
  G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__MetaLN_TFile.tagnum = -1 ;
  G__G__MetaLN_TClassGenerator.tagnum = -1 ;
  G__G__MetaLN_TClassMenuItem.tagnum = -1 ;
  G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType.tagnum = -1 ;
  G__G__MetaLN_TClassMenuItemcLcLdA.tagnum = -1 ;
  G__G__MetaLN_TDataType.tagnum = -1 ;
  G__G__MetaLN_TDataMembercLcLdA.tagnum = -1 ;
  G__G__MetaLN_EDataType.tagnum = -1 ;
  G__G__MetaLN_TFunction.tagnum = -1 ;
  G__G__MetaLN_TGlobal.tagnum = -1 ;
  G__G__MetaLN_TEnv.tagnum = -1 ;
  G__G__MetaLN_G__value.tagnum = -1 ;
  G__G__MetaLN_TInterpreter.tagnum = -1 ;
  G__G__MetaLN_TInterpretercLcLEErrorCode.tagnum = -1 ;
  G__G__MetaLN_TIsAProxy.tagnum = -1 ;
  G__G__MetaLN_TMethodArg.tagnum = -1 ;
  G__G__MetaLN_TMethodCallcLcLEReturnType.tagnum = -1 ;
  G__G__MetaLN_EMenuItemKind.tagnum = -1 ;
  G__G__MetaLN_TRealDatacLcLdA.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTSchemaRule.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t.tagnum = -1 ;
  G__G__MetaLN_pairlEintcOintgR.tagnum = -1 ;
  G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__MetaLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTSchemaMatch.tagnum = -1 ;
  G__G__MetaLN_ROOTcLcLTSchemaRuleSetcLcLEConsistencyCheck.tagnum = -1 ;
  G__G__MetaLN_TStreamerBasicType.tagnum = -1 ;
  G__G__MetaLN_TStreamerElementcLcLESTLtype.tagnum = -1 ;
  G__G__MetaLN_TStreamerElementcLcLdA.tagnum = -1 ;
  G__G__MetaLN_TStreamerBase.tagnum = -1 ;
  G__G__MetaLN_TStreamerBasicPointer.tagnum = -1 ;
  G__G__MetaLN_TStreamerLoop.tagnum = -1 ;
  G__G__MetaLN_TStreamerObject.tagnum = -1 ;
  G__G__MetaLN_TStreamerObjectAny.tagnum = -1 ;
  G__G__MetaLN_TStreamerObjectPointer.tagnum = -1 ;
  G__G__MetaLN_TStreamerObjectAnyPointer.tagnum = -1 ;
  G__G__MetaLN_TStreamerString.tagnum = -1 ;
  G__G__MetaLN_TStreamerSTL.tagnum = -1 ;
  G__G__MetaLN_TStreamerSTLcLcLdA.tagnum = -1 ;
  G__G__MetaLN_TStreamerSTLstring.tagnum = -1 ;
  G__G__MetaLN_TStreamerArtificial.tagnum = -1 ;
  G__G__MetaLN_TToggle.tagnum = -1 ;
  G__G__MetaLN_TOrdCollection.tagnum = -1 ;
  G__G__MetaLN_TToggleGroup.tagnum = -1 ;
  G__G__MetaLN_TVirtualStreamerInfocLcLdA.tagnum = -1 ;
  G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Meta() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__MetaLN_type_info);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TClass),sizeof(TClass),-1,65280,"Dictionary containing class information",G__setup_memvarTClass,G__setup_memfuncTClass);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TClassStreamer),sizeof(TClassStreamer),-1,296704,(char*)NULL,G__setup_memvarTClassStreamer,G__setup_memfuncTClassStreamer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TMemberStreamer),sizeof(TMemberStreamer),-1,296704,(char*)NULL,G__setup_memvarTMemberStreamer,G__setup_memfuncTMemberStreamer);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TVirtualCollectionProxy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TVirtualIsAProxy),sizeof(TVirtualIsAProxy),-1,1026,(char*)NULL,G__setup_memvarTVirtualIsAProxy,G__setup_memfuncTVirtualIsAProxy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOT),0,-1,0,(char*)NULL,G__setup_memvarROOT,G__setup_memfuncROOT);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTInitBehavior);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_string);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTCollectionProxyInfo);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TList);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TObjArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TMethod),sizeof(TMethod),-1,65280,"Dictionary for a class member function (method)",G__setup_memvarTMethod,G__setup_memfuncTMethod);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TVirtualStreamerInfo),sizeof(TVirtualStreamerInfo),-1,130855,"Abstract Interface describing Streamer information for one class",G__setup_memvarTVirtualStreamerInfo,G__setup_memfuncTVirtualStreamerInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerElement),sizeof(TStreamerElement),-1,130816,"Base class for one element (data member) to be Streamed",G__setup_memvarTStreamerElement,G__setup_memfuncTStreamerElement);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_EProperty),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TDictionary),sizeof(TDictionary),-1,62721,"ABC defining interface to dictionary",G__setup_memvarTDictionary,G__setup_memfuncTDictionary);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TDictionarycLcLESTLType);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TCollection);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TSeqCollection);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TBaseClass),sizeof(TBaseClass),-1,65280,"Description of a base class",G__setup_memvarTBaseClass,G__setup_memfuncTBaseClass);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TDataMember),sizeof(TDataMember),-1,65280,"Dictionary for a class data member",G__setup_memvarTDataMember,G__setup_memfuncTDataMember);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TClassRef),sizeof(TClassRef),-1,298752,(char*)NULL,G__setup_memvarTClassRef,G__setup_memfuncTClassRef);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TRealData),sizeof(TRealData),-1,327424,"Description of persistent data members",G__setup_memvarTRealData,G__setup_memfuncTRealData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TMethodCall),sizeof(TMethodCall),-1,65280,"Method calling interface",G__setup_memvarTMethodCall,G__setup_memfuncTMethodCall);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TVirtualRefProxy);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_THashTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTSchemaRuleSet),sizeof(ROOT::TSchemaRuleSet),-1,95488,(char*)NULL,G__setup_memvarROOTcLcLTSchemaRuleSet,G__setup_memfuncROOTcLcLTSchemaRuleSet);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTMapTypeToTClass);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TClasscLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TClasscLcLENewType);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TClassGenerator),sizeof(TClassGenerator),-1,292098,"interface for TClass generators",G__setup_memvarTClassGenerator,G__setup_memfuncTClassGenerator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TClassMenuItem),sizeof(TClassMenuItem),-1,65280,"One element of the class context menu",G__setup_memvarTClassMenuItem,G__setup_memfuncTClassMenuItem);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TClassMenuItemcLcLEClassMenuItemType);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TClassMenuItemcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TDataType),sizeof(TDataType),-1,65280,"Basic data type descriptor",G__setup_memvarTDataType,G__setup_memfuncTDataType);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TDataMembercLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_EDataType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TFunction),sizeof(TFunction),-1,65280,"Dictionary for global function",G__setup_memvarTFunction,G__setup_memfuncTFunction);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TGlobal),sizeof(TGlobal),-1,65280,"Global variable class",G__setup_memvarTGlobal,G__setup_memfuncTGlobal);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TEnv);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_G__value);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TInterpreter),sizeof(TInterpreter),-1,62781,"ABC defining interface to generic interpreter",G__setup_memvarTInterpreter,G__setup_memfuncTInterpreter);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TInterpretercLcLEErrorCode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TIsAProxy),sizeof(TIsAProxy),-1,36352,(char*)NULL,G__setup_memvarTIsAProxy,G__setup_memfuncTIsAProxy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TMethodArg),sizeof(TMethodArg),-1,65280,"Dictionary for a method argument",G__setup_memvarTMethodArg,G__setup_memfuncTMethodArg);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TMethodCallcLcLEReturnType);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_EMenuItemKind);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TRealDatacLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTSchemaRule),sizeof(ROOT::TSchemaRule),-1,294656,(char*)NULL,G__setup_memvarROOTcLcLTSchemaRule,G__setup_memfuncROOTcLcLTSchemaRule);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLTSources),sizeof(ROOT::TSchemaRule::TSources),-1,323840,(char*)NULL,G__setup_memvarROOTcLcLTSchemaRulecLcLTSources,G__setup_memfuncROOTcLcLTSchemaRulecLcLTSources);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTSchemaRulecLcLRuleType_t);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_pairlEintcOintgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),sizeof(vector<pair<int,int>,allocator<pair<int,int> > >),-1,298752,(char*)NULL,G__setup_memvarvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR,G__setup_memfuncvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTSchemaMatch),sizeof(ROOT::TSchemaMatch),-1,291840,(char*)NULL,G__setup_memvarROOTcLcLTSchemaMatch,G__setup_memfuncROOTcLcLTSchemaMatch);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_ROOTcLcLTSchemaRuleSetcLcLEConsistencyCheck);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerBasicType),sizeof(TStreamerBasicType),-1,130816,"Streamer element for a basic type",G__setup_memvarTStreamerBasicType,G__setup_memfuncTStreamerBasicType);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerElementcLcLESTLtype);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerElementcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerBase),sizeof(TStreamerBase),-1,130816,"Streamer element of type base class",G__setup_memvarTStreamerBase,G__setup_memfuncTStreamerBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerBasicPointer),sizeof(TStreamerBasicPointer),-1,130816,"Streamer element for a pointer to a basic type",G__setup_memvarTStreamerBasicPointer,G__setup_memfuncTStreamerBasicPointer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerLoop),sizeof(TStreamerLoop),-1,130816,"Streamer element for a pointer to an array of objects",G__setup_memvarTStreamerLoop,G__setup_memfuncTStreamerLoop);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerObject),sizeof(TStreamerObject),-1,130816,"Streamer element of type object",G__setup_memvarTStreamerObject,G__setup_memfuncTStreamerObject);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerObjectAny),sizeof(TStreamerObjectAny),-1,130816,"Streamer element of type object other than TObject",G__setup_memvarTStreamerObjectAny,G__setup_memfuncTStreamerObjectAny);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerObjectPointer),sizeof(TStreamerObjectPointer),-1,130816,"Streamer element of type pointer to a TObject",G__setup_memvarTStreamerObjectPointer,G__setup_memfuncTStreamerObjectPointer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerObjectAnyPointer),sizeof(TStreamerObjectAnyPointer),-1,130816,"Streamer element of type pointer to a non TObject",G__setup_memvarTStreamerObjectAnyPointer,G__setup_memfuncTStreamerObjectAnyPointer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerString),sizeof(TStreamerString),-1,130816,"Streamer element of type TString",G__setup_memvarTStreamerString,G__setup_memfuncTStreamerString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerSTL),sizeof(TStreamerSTL),-1,130816,"Streamer element of type STL container",G__setup_memvarTStreamerSTL,G__setup_memfuncTStreamerSTL);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerSTLcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerSTLstring),sizeof(TStreamerSTLstring),-1,130816,"Streamer element of type  C++ string",G__setup_memvarTStreamerSTLstring,G__setup_memfuncTStreamerSTLstring);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TStreamerArtificial),sizeof(TStreamerArtificial),-1,129536,"StreamerElement injected by a TSchemaRule. Transient only to preverse forward compatibility.",G__setup_memvarTStreamerArtificial,G__setup_memfuncTStreamerArtificial);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TToggle),sizeof(TToggle),-1,61696,"Facility for toggling datamembers on/off",G__setup_memvarTToggle,G__setup_memfuncTToggle);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TOrdCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MetaLN_TToggleGroup),sizeof(TToggleGroup),-1,65280,"Group of contex-menu toggle objects",G__setup_memvarTToggleGroup,G__setup_memfuncTToggleGroup);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TVirtualStreamerInfocLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MetaLN_TVirtualStreamerInfocLcLEReadWrite);
}
extern "C" void G__cpp_setupG__Meta(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Meta()");
  G__set_cpp_environmentG__Meta();
  G__cpp_setup_tagtableG__Meta();

  G__cpp_setup_inheritanceG__Meta();

  G__cpp_setup_typetableG__Meta();

  G__cpp_setup_memvarG__Meta();

  G__cpp_setup_memfuncG__Meta();
  G__cpp_setup_globalG__Meta();
  G__cpp_setup_funcG__Meta();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Meta();
  return;
}
class G__cpp_setup_initG__Meta {
  public:
    G__cpp_setup_initG__Meta() { G__add_setup_func("G__Meta",(G__incsetup)(&G__cpp_setupG__Meta)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Meta() { G__remove_setup_func("G__Meta"); }
};
G__cpp_setup_initG__Meta G__cpp_setup_initializerG__Meta;

---