G__Base1.cxx

Go to the documentation of this file.

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

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

#define R__DICTIONARY_FILENAME coredIbasedIsrcdIG__Base1
#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__Base1.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 ::TRootIOCtor TRootIOCtor;
      #else
      class TRootIOCtor  {
         public:
         //friend XX;
      };
      #endif

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

namespace ROOT {
   void TBuffer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TBuffer(void *p);
   static void deleteArray_TBuffer(void *p);
   static void destruct_TBuffer(void *p);
   static void streamer_TBuffer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDirectory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDirectory(void *p = 0);
   static void *newArray_TDirectory(Long_t size, void *p);
   static void delete_TDirectory(void *p);
   static void deleteArray_TDirectory(void *p);
   static void destruct_TDirectory(void *p);
   static void streamer_TDirectory(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootIOCtor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TRootIOCtor_Dictionary();
   static void *new_TRootIOCtor(void *p = 0);
   static void *newArray_TRootIOCtor(Long_t size, void *p);
   static void delete_TRootIOCtor(void *p);
   static void deleteArray_TRootIOCtor(void *p);
   static void destruct_TRootIOCtor(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRootIOCtor*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TRootIOCtor) == sizeof(::ROOT::Shadow::TRootIOCtor));
      ::TRootIOCtor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TRootIOCtor),0);
      static ::ROOT::TGenericClassInfo 
         instance("TRootIOCtor", "include/TRootIOCtor.h", 33,
                  typeid(::TRootIOCtor), DefineBehavior(ptr, ptr),
                  &TRootIOCtor_ShowMembers, &TRootIOCtor_Dictionary, isa_proxy, 4,
                  sizeof(::TRootIOCtor) );
      instance.SetNew(&new_TRootIOCtor);
      instance.SetNewArray(&newArray_TRootIOCtor);
      instance.SetDelete(&delete_TRootIOCtor);
      instance.SetDeleteArray(&deleteArray_TRootIOCtor);
      instance.SetDestructor(&destruct_TRootIOCtor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRootIOCtor*)
   {
      return GenerateInitInstanceLocal((::TRootIOCtor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRootIOCtor*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TRootIOCtor_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TRootIOCtor*)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/TROOT.h", 279,
                     ::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 TBrowser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBrowser(void *p = 0);
   static void *newArray_TBrowser(Long_t size, void *p);
   static void delete_TBrowser(void *p);
   static void deleteArray_TBrowser(void *p);
   static void destruct_TBrowser(void *p);

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

namespace ROOT {
   void TApplicationImp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TApplicationImp(void *p = 0);
   static void *newArray_TApplicationImp(Long_t size, void *p);
   static void delete_TApplicationImp(void *p);
   static void deleteArray_TApplicationImp(void *p);
   static void destruct_TApplicationImp(void *p);
   static void streamer_TApplicationImp(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TApplication_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TApplication(void *p);
   static void deleteArray_TApplication(void *p);
   static void destruct_TApplication(void *p);
   static void streamer_TApplication(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAtt3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAtt3D(void *p = 0);
   static void *newArray_TAtt3D(Long_t size, void *p);
   static void delete_TAtt3D(void *p);
   static void deleteArray_TAtt3D(void *p);
   static void destruct_TAtt3D(void *p);

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

namespace ROOT {
   void TAttAxis_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttAxis(void *p = 0);
   static void *newArray_TAttAxis(Long_t size, void *p);
   static void delete_TAttAxis(void *p);
   static void deleteArray_TAttAxis(void *p);
   static void destruct_TAttAxis(void *p);
   static void streamer_TAttAxis(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAttBBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TAttBBox(void *p);
   static void deleteArray_TAttBBox(void *p);
   static void destruct_TAttBBox(void *p);

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

namespace ROOT {
   void TAttFill_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttFill(void *p = 0);
   static void *newArray_TAttFill(Long_t size, void *p);
   static void delete_TAttFill(void *p);
   static void deleteArray_TAttFill(void *p);
   static void destruct_TAttFill(void *p);

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

namespace ROOT {
   void TAttLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttLine(void *p = 0);
   static void *newArray_TAttLine(Long_t size, void *p);
   static void delete_TAttLine(void *p);
   static void deleteArray_TAttLine(void *p);
   static void destruct_TAttLine(void *p);

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

namespace ROOT {
   void TAttMarker_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttMarker(void *p = 0);
   static void *newArray_TAttMarker(Long_t size, void *p);
   static void delete_TAttMarker(void *p);
   static void deleteArray_TAttMarker(void *p);
   static void destruct_TAttMarker(void *p);

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

namespace ROOT {
   void TAttPad_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttPad(void *p = 0);
   static void *newArray_TAttPad(Long_t size, void *p);
   static void delete_TAttPad(void *p);
   static void deleteArray_TAttPad(void *p);
   static void destruct_TAttPad(void *p);
   static void streamer_TAttPad(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAttText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttText(void *p = 0);
   static void *newArray_TAttText(Long_t size, void *p);
   static void delete_TAttText(void *p);
   static void deleteArray_TAttText(void *p);
   static void destruct_TAttText(void *p);

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

namespace ROOT {
   void TBenchmark_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBenchmark(void *p = 0);
   static void *newArray_TBenchmark(Long_t size, void *p);
   static void delete_TBenchmark(void *p);
   static void deleteArray_TBenchmark(void *p);
   static void destruct_TBenchmark(void *p);

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

namespace ROOT {
   void TBrowserImp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBrowserImp(void *p = 0);
   static void *newArray_TBrowserImp(Long_t size, void *p);
   static void delete_TBrowserImp(void *p);
   static void deleteArray_TBrowserImp(void *p);
   static void destruct_TBrowserImp(void *p);

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

namespace ROOT {
   void TContextMenu_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TContextMenu(void *p);
   static void deleteArray_TContextMenu(void *p);
   static void destruct_TContextMenu(void *p);

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

namespace ROOT {
   void TBuffer3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TBuffer3D(void *p);
   static void deleteArray_TBuffer3D(void *p);
   static void destruct_TBuffer3D(void *p);
   static void streamer_TBuffer3D(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TCanvasImp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCanvasImp(void *p = 0);
   static void *newArray_TCanvasImp(Long_t size, void *p);
   static void delete_TCanvasImp(void *p);
   static void deleteArray_TCanvasImp(void *p);
   static void destruct_TCanvasImp(void *p);
   static void streamer_TCanvasImp(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TColor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TColor(void *p = 0);
   static void *newArray_TColor(Long_t size, void *p);
   static void delete_TColor(void *p);
   static void deleteArray_TColor(void *p);
   static void destruct_TColor(void *p);

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

namespace ROOT {
   void TContextMenuImp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TContextMenuImp(void *p = 0);
   static void *newArray_TContextMenuImp(Long_t size, void *p);
   static void delete_TContextMenuImp(void *p);
   static void deleteArray_TContextMenuImp(void *p);
   static void destruct_TContextMenuImp(void *p);

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

namespace ROOT {
   void TVirtualPad_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualPad(void *p);
   static void deleteArray_TVirtualPad(void *p);
   static void destruct_TVirtualPad(void *p);
   static void streamer_TVirtualPad(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TControlBarImp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TControlBarImp(void *p);
   static void deleteArray_TControlBarImp(void *p);
   static void destruct_TControlBarImp(void *p);

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

namespace ROOT {
   void TDatime_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDatime(void *p = 0);
   static void *newArray_TDatime(Long_t size, void *p);
   static void delete_TDatime(void *p);
   static void deleteArray_TDatime(void *p);
   static void destruct_TDatime(void *p);
   static void streamer_TDatime(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDatime*)
   {
      ::TDatime *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDatime >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDatime", ::TDatime::Class_Version(), "include/TDatime.h", 38,
                  typeid(::TDatime), DefineBehavior(ptr, ptr),
                  &::TDatime::Dictionary, isa_proxy, 1,
                  sizeof(::TDatime) );
      instance.SetNew(&new_TDatime);
      instance.SetNewArray(&newArray_TDatime);
      instance.SetDelete(&delete_TDatime);
      instance.SetDeleteArray(&deleteArray_TDatime);
      instance.SetDestructor(&destruct_TDatime);
      instance.SetStreamerFunc(&streamer_TDatime);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDatime*)
   {
      return GenerateInitInstanceLocal((::TDatime*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDatime*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEnv_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEnv(void *p = 0);
   static void *newArray_TEnv(Long_t size, void *p);
   static void delete_TEnv(void *p);
   static void deleteArray_TEnv(void *p);
   static void destruct_TEnv(void *p);

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

namespace ROOT {
   void TEnvRec_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEnvRec(void *p = 0);
   static void *newArray_TEnvRec(Long_t size, void *p);
   static void delete_TEnvRec(void *p);
   static void deleteArray_TEnvRec(void *p);
   static void destruct_TEnvRec(void *p);

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

namespace ROOT {
   void TInspectorImp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TInspectorImp(void *p = 0);
   static void *newArray_TInspectorImp(Long_t size, void *p);
   static void delete_TInspectorImp(void *p);
   static void deleteArray_TInspectorImp(void *p);
   static void destruct_TInspectorImp(void *p);

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

namespace ROOT {
   void TGuiFactory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGuiFactory(void *p = 0);
   static void *newArray_TGuiFactory(Long_t size, void *p);
   static void delete_TGuiFactory(void *p);
   static void deleteArray_TGuiFactory(void *p);
   static void destruct_TGuiFactory(void *p);
   static void streamer_TGuiFactory(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TFileHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TFileHandler(void *p);
   static void deleteArray_TFileHandler(void *p);
   static void destruct_TFileHandler(void *p);

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

namespace ROOT {
   void TStyle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStyle(void *p = 0);
   static void *newArray_TStyle(Long_t size, void *p);
   static void delete_TStyle(void *p);
   static void deleteArray_TStyle(void *p);
   static void destruct_TStyle(void *p);

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

namespace ROOT {
   void TVirtualFFT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualFFT(void *p);
   static void deleteArray_TVirtualFFT(void *p);
   static void destruct_TVirtualFFT(void *p);
   static void streamer_TVirtualFFT(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualViewer3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualViewer3D(void *p);
   static void deleteArray_TVirtualViewer3D(void *p);
   static void destruct_TVirtualViewer3D(void *p);
   static void streamer_TVirtualViewer3D(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualGLPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualGLPainter(void *p);
   static void deleteArray_TVirtualGLPainter(void *p);
   static void destruct_TVirtualGLPainter(void *p);
   static void streamer_TVirtualGLPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualGLManip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualGLManip(void *p);
   static void deleteArray_TVirtualGLManip(void *p);
   static void destruct_TVirtualGLManip(void *p);
   static void streamer_TVirtualGLManip(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLManager(void *p);
   static void deleteArray_TGLManager(void *p);
   static void destruct_TGLManager(void *p);
   static void streamer_TGLManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPaintDevice_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPaintDevice(void *p);
   static void deleteArray_TGLPaintDevice(void *p);
   static void destruct_TGLPaintDevice(void *p);
   static void streamer_TGLPaintDevice(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualPadEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualPadEditor(void *p);
   static void deleteArray_TVirtualPadEditor(void *p);
   static void destruct_TVirtualPadEditor(void *p);
   static void streamer_TVirtualPadEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualX_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TVirtualX(void *p = 0);
   static void *newArray_TVirtualX(Long_t size, void *p);
   static void delete_TVirtualX(void *p);
   static void deleteArray_TVirtualX(void *p);
   static void destruct_TVirtualX(void *p);

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

namespace ROOT {
   void TVirtualPadPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualPadPainter(void *p);
   static void deleteArray_TVirtualPadPainter(void *p);
   static void destruct_TVirtualPadPainter(void *p);
   static void streamer_TVirtualPadPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualPS_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualPS(void *p);
   static void deleteArray_TVirtualPS(void *p);
   static void destruct_TVirtualPS(void *p);
   static void streamer_TVirtualPS(TBuffer &buf, void *obj);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   }
}

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

   TObject::Streamer(R__b);
   TQObject::Streamer(R__b);
}

//______________________________________________________________________________
void TApplication::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TApplication.
      TClass *R__cl = ::TApplication::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArgc", &fArgc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArgv", &fArgv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAppImp", &fAppImp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRunning", &fIsRunning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReturnFromRun", &fReturnFromRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoLog", &fNoLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoLogo", &fNoLogo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuit", &fQuit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMemstat", &fUseMemstat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFiles", &fFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
      R__insp.InspectMember(fWorkDir, "fWorkDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdleCommand", &fIdleCommand);
      R__insp.InspectMember(fIdleCommand, "fIdleCommand.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIdleTimer", &fIdleTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSigHandler", &fSigHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExitOnException", &fExitOnException);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAppRemote", &fAppRemote);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TApplicationImp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TApplicationImp : new ::TApplicationImp;
   }
   static void *newArray_TApplicationImp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TApplicationImp[nElements] : new ::TApplicationImp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TApplicationImp(void *p) {
      delete ((::TApplicationImp*)p);
   }
   static void deleteArray_TApplicationImp(void *p) {
      delete [] ((::TApplicationImp*)p);
   }
   static void destruct_TApplicationImp(void *p) {
      typedef ::TApplicationImp current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TApplicationImp(TBuffer &buf, void *obj) {
      ((::TApplicationImp*)obj)->::TApplicationImp::Streamer(buf);
   }
} // end of namespace ROOT for class ::TApplicationImp

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttFill(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttFill : new ::TAttFill;
   }
   static void *newArray_TAttFill(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttFill[nElements] : new ::TAttFill[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttFill(void *p) {
      delete ((::TAttFill*)p);
   }
   static void deleteArray_TAttFill(void *p) {
      delete [] ((::TAttFill*)p);
   }
   static void destruct_TAttFill(void *p) {
      typedef ::TAttFill current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TAttFill

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttLine(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttLine : new ::TAttLine;
   }
   static void *newArray_TAttLine(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttLine[nElements] : new ::TAttLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttLine(void *p) {
      delete ((::TAttLine*)p);
   }
   static void deleteArray_TAttLine(void *p) {
      delete [] ((::TAttLine*)p);
   }
   static void destruct_TAttLine(void *p) {
      typedef ::TAttLine current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TAttLine

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttMarker(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttMarker : new ::TAttMarker;
   }
   static void *newArray_TAttMarker(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttMarker[nElements] : new ::TAttMarker[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttMarker(void *p) {
      delete ((::TAttMarker*)p);
   }
   static void deleteArray_TAttMarker(void *p) {
      delete [] ((::TAttMarker*)p);
   }
   static void destruct_TAttMarker(void *p) {
      typedef ::TAttMarker current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TAttMarker

//______________________________________________________________________________
void TAttPad::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttPad.
      TClass *R__cl = ::TAttPad::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftMargin", &fLeftMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRightMargin", &fRightMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBottomMargin", &fBottomMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTopMargin", &fTopMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXfile", &fXfile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYfile", &fYfile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAfile", &fAfile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXstat", &fXstat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYstat", &fYstat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAstat", &fAstat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameFillColor", &fFrameFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineColor", &fFrameLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameFillStyle", &fFrameFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineStyle", &fFrameLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineWidth", &fFrameLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameBorderSize", &fFrameBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameBorderMode", &fFrameBorderMode);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttPad(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttPad : new ::TAttPad;
   }
   static void *newArray_TAttPad(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttPad[nElements] : new ::TAttPad[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttPad(void *p) {
      delete ((::TAttPad*)p);
   }
   static void deleteArray_TAttPad(void *p) {
      delete [] ((::TAttPad*)p);
   }
   static void destruct_TAttPad(void *p) {
      typedef ::TAttPad current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttPad(TBuffer &buf, void *obj) {
      ((::TAttPad*)obj)->::TAttPad::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttPad

//______________________________________________________________________________
void TAttAxis::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttAxis.
      TClass *R__cl = ::TAttAxis::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdivisions", &fNdivisions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisColor", &fAxisColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelColor", &fLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelFont", &fLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelOffset", &fLabelOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelSize", &fLabelSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTickLength", &fTickLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleOffset", &fTitleOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleSize", &fTitleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleColor", &fTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleFont", &fTitleFont);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttAxis(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttAxis : new ::TAttAxis;
   }
   static void *newArray_TAttAxis(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttAxis[nElements] : new ::TAttAxis[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttAxis(void *p) {
      delete ((::TAttAxis*)p);
   }
   static void deleteArray_TAttAxis(void *p) {
      delete [] ((::TAttAxis*)p);
   }
   static void destruct_TAttAxis(void *p) {
      typedef ::TAttAxis current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttAxis(TBuffer &buf, void *obj) {
      ((::TAttAxis*)obj)->::TAttAxis::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttAxis

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttText(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttText : new ::TAttText;
   }
   static void *newArray_TAttText(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttText[nElements] : new ::TAttText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttText(void *p) {
      delete ((::TAttText*)p);
   }
   static void deleteArray_TAttText(void *p) {
      delete [] ((::TAttText*)p);
   }
   static void destruct_TAttText(void *p) {
      typedef ::TAttText current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TAttText

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAtt3D(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAtt3D : new ::TAtt3D;
   }
   static void *newArray_TAtt3D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAtt3D[nElements] : new ::TAtt3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAtt3D(void *p) {
      delete ((::TAtt3D*)p);
   }
   static void deleteArray_TAtt3D(void *p) {
      delete [] ((::TAtt3D*)p);
   }
   static void destruct_TAtt3D(void *p) {
      typedef ::TAtt3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TAtt3D

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TAttBBox(void *p) {
      delete ((::TAttBBox*)p);
   }
   static void deleteArray_TAttBBox(void *p) {
      delete [] ((::TAttBBox*)p);
   }
   static void destruct_TAttBBox(void *p) {
      typedef ::TAttBBox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TAttBBox

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

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

//______________________________________________________________________________
void TBenchmark::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBenchmark.
      TClass *R__cl = ::TBenchmark::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbench", &fNbench);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmax", &fNmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNames", &fNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRealTime", &fRealTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCpuTime", &fCpuTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBenchmark(void *p) {
      return  p ? new(p) ::TBenchmark : new ::TBenchmark;
   }
   static void *newArray_TBenchmark(Long_t nElements, void *p) {
      return p ? new(p) ::TBenchmark[nElements] : new ::TBenchmark[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBenchmark(void *p) {
      delete ((::TBenchmark*)p);
   }
   static void deleteArray_TBenchmark(void *p) {
      delete [] ((::TBenchmark*)p);
   }
   static void destruct_TBenchmark(void *p) {
      typedef ::TBenchmark current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBenchmark

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBrowser(void *p) {
      return  p ? new(p) ::TBrowser : new ::TBrowser;
   }
   static void *newArray_TBrowser(Long_t nElements, void *p) {
      return p ? new(p) ::TBrowser[nElements] : new ::TBrowser[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBrowser(void *p) {
      delete ((::TBrowser*)p);
   }
   static void deleteArray_TBrowser(void *p) {
      delete [] ((::TBrowser*)p);
   }
   static void destruct_TBrowser(void *p) {
      typedef ::TBrowser current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBrowser

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBrowserImp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TBrowserImp : new ::TBrowserImp;
   }
   static void *newArray_TBrowserImp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TBrowserImp[nElements] : new ::TBrowserImp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBrowserImp(void *p) {
      delete ((::TBrowserImp*)p);
   }
   static void deleteArray_TBrowserImp(void *p) {
      delete [] ((::TBrowserImp*)p);
   }
   static void destruct_TBrowserImp(void *p) {
      typedef ::TBrowserImp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBrowserImp

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TBuffer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBuffer.
      TClass *R__cl = ::TBuffer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufSize", &fBufSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuffer", &fBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufCur", &fBufCur);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufMax", &fBufMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReAllocFunc", &fReAllocFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheStack", (void*)&fCacheStack);
      R__insp.InspectMember("TBuffer::CacheList_t", (void*)&fCacheStack, "fCacheStack.", false);
      TObject::ShowMembers(R__insp);
}

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

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TRootIOCtor*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootIOCtor(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TRootIOCtor : new ::TRootIOCtor;
   }
   static void *newArray_TRootIOCtor(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TRootIOCtor[nElements] : new ::TRootIOCtor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootIOCtor(void *p) {
      delete ((::TRootIOCtor*)p);
   }
   static void deleteArray_TRootIOCtor(void *p) {
      delete [] ((::TRootIOCtor*)p);
   }
   static void destruct_TRootIOCtor(void *p) {
      typedef ::TRootIOCtor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRootIOCtor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCanvasImp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCanvasImp : new ::TCanvasImp;
   }
   static void *newArray_TCanvasImp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCanvasImp[nElements] : new ::TCanvasImp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCanvasImp(void *p) {
      delete ((::TCanvasImp*)p);
   }
   static void deleteArray_TCanvasImp(void *p) {
      delete [] ((::TCanvasImp*)p);
   }
   static void destruct_TCanvasImp(void *p) {
      typedef ::TCanvasImp current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TCanvasImp(TBuffer &buf, void *obj) {
      ((::TCanvasImp*)obj)->::TCanvasImp::Streamer(buf);
   }
} // end of namespace ROOT for class ::TCanvasImp

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

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

//______________________________________________________________________________
void TColor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TColor.
      TClass *R__cl = ::TColor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRed", &fRed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGreen", &fGreen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBlue", &fBlue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHue", &fHue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLight", &fLight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaturation", &fSaturation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &fAlpha);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TColor(void *p) {
      return  p ? new(p) ::TColor : new ::TColor;
   }
   static void *newArray_TColor(Long_t nElements, void *p) {
      return p ? new(p) ::TColor[nElements] : new ::TColor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TColor(void *p) {
      delete ((::TColor*)p);
   }
   static void deleteArray_TColor(void *p) {
      delete [] ((::TColor*)p);
   }
   static void destruct_TColor(void *p) {
      typedef ::TColor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TColor

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

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

//______________________________________________________________________________
void TContextMenu::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TContextMenu.
      TClass *R__cl = ::TContextMenu::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContextMenuImp", &fContextMenuImp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMethod", &fSelectedMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedObject", &fSelectedObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCalledObject", &fCalledObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMenuItem", &fSelectedMenuItem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedCanvas", &fSelectedCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedPad", &fSelectedPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrowser", &fBrowser);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TContextMenu(void *p) {
      delete ((::TContextMenu*)p);
   }
   static void deleteArray_TContextMenu(void *p) {
      delete [] ((::TContextMenu*)p);
   }
   static void destruct_TContextMenu(void *p) {
      typedef ::TContextMenu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TContextMenu

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TContextMenuImp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TContextMenuImp : new ::TContextMenuImp;
   }
   static void *newArray_TContextMenuImp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TContextMenuImp[nElements] : new ::TContextMenuImp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TContextMenuImp(void *p) {
      delete ((::TContextMenuImp*)p);
   }
   static void deleteArray_TContextMenuImp(void *p) {
      delete [] ((::TContextMenuImp*)p);
   }
   static void destruct_TContextMenuImp(void *p) {
      typedef ::TContextMenuImp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TContextMenuImp

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TControlBarImp(void *p) {
      delete ((::TControlBarImp*)p);
   }
   static void deleteArray_TControlBarImp(void *p) {
      delete [] ((::TControlBarImp*)p);
   }
   static void destruct_TControlBarImp(void *p) {
      typedef ::TControlBarImp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TControlBarImp

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TInspectorImp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TInspectorImp : new ::TInspectorImp;
   }
   static void *newArray_TInspectorImp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TInspectorImp[nElements] : new ::TInspectorImp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TInspectorImp(void *p) {
      delete ((::TInspectorImp*)p);
   }
   static void deleteArray_TInspectorImp(void *p) {
      delete [] ((::TInspectorImp*)p);
   }
   static void destruct_TInspectorImp(void *p) {
      typedef ::TInspectorImp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TInspectorImp

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDatime(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TDatime : new ::TDatime;
   }
   static void *newArray_TDatime(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TDatime[nElements] : new ::TDatime[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDatime(void *p) {
      delete ((::TDatime*)p);
   }
   static void deleteArray_TDatime(void *p) {
      delete [] ((::TDatime*)p);
   }
   static void destruct_TDatime(void *p) {
      typedef ::TDatime current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDatime(TBuffer &buf, void *obj) {
      ((::TDatime*)obj)->::TDatime::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDatime

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TNamed::Streamer(R__b);
      R__b >> fMother;
      R__b >> fList;
      fUUID.Streamer(R__b);
      R__b.CheckByteCount(R__s, R__c, TDirectory::IsA());
   } else {
      R__c = R__b.WriteVersion(TDirectory::IsA(), kTRUE);
      TNamed::Streamer(R__b);
      R__b << fMother;
      R__b << fList;
      fUUID.Streamer(R__b);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TDirectory::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDirectory.
      TClass *R__cl = ::TDirectory::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMother", &fMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUUID", &fUUID);
      R__insp.InspectMember(fUUID, "fUUID.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPathBuffer", &fPathBuffer);
      R__insp.InspectMember(fPathBuffer, "fPathBuffer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContext", &fContext);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDirectory(void *p) {
      return  p ? new(p) ::TDirectory : new ::TDirectory;
   }
   static void *newArray_TDirectory(Long_t nElements, void *p) {
      return p ? new(p) ::TDirectory[nElements] : new ::TDirectory[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDirectory(void *p) {
      delete ((::TDirectory*)p);
   }
   static void deleteArray_TDirectory(void *p) {
      delete [] ((::TDirectory*)p);
   }
   static void destruct_TDirectory(void *p) {
      typedef ::TDirectory current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDirectory(TBuffer &buf, void *obj) {
      ((::TDirectory*)obj)->::TDirectory::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDirectory

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEnv(void *p) {
      return  p ? new(p) ::TEnv : new ::TEnv;
   }
   static void *newArray_TEnv(Long_t nElements, void *p) {
      return p ? new(p) ::TEnv[nElements] : new ::TEnv[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEnv(void *p) {
      delete ((::TEnv*)p);
   }
   static void deleteArray_TEnv(void *p) {
      delete [] ((::TEnv*)p);
   }
   static void destruct_TEnv(void *p) {
      typedef ::TEnv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEnv

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEnvRec(void *p) {
      return  p ? new(p) ::TEnvRec : new ::TEnvRec;
   }
   static void *newArray_TEnvRec(Long_t nElements, void *p) {
      return p ? new(p) ::TEnvRec[nElements] : new ::TEnvRec[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEnvRec(void *p) {
      delete ((::TEnvRec*)p);
   }
   static void deleteArray_TEnvRec(void *p) {
      delete [] ((::TEnvRec*)p);
   }
   static void destruct_TEnvRec(void *p) {
      typedef ::TEnvRec current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEnvRec

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TFileHandler(void *p) {
      delete ((::TFileHandler*)p);
   }
   static void deleteArray_TFileHandler(void *p) {
      delete [] ((::TFileHandler*)p);
   }
   static void destruct_TFileHandler(void *p) {
      typedef ::TFileHandler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFileHandler

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

   TNamed::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGuiFactory(void *p) {
      return  p ? new(p) ::TGuiFactory : new ::TGuiFactory;
   }
   static void *newArray_TGuiFactory(Long_t nElements, void *p) {
      return p ? new(p) ::TGuiFactory[nElements] : new ::TGuiFactory[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGuiFactory(void *p) {
      delete ((::TGuiFactory*)p);
   }
   static void deleteArray_TGuiFactory(void *p) {
      delete [] ((::TGuiFactory*)p);
   }
   static void destruct_TGuiFactory(void *p) {
      typedef ::TGuiFactory current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGuiFactory(TBuffer &buf, void *obj) {
      ((::TGuiFactory*)obj)->::TGuiFactory::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGuiFactory

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

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

//______________________________________________________________________________
void TStyle::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStyle.
      TClass *R__cl = ::TStyle::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXaxis", &fXaxis);
      R__insp.InspectMember(fXaxis, "fXaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYaxis", &fYaxis);
      R__insp.InspectMember(fYaxis, "fYaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZaxis", &fZaxis);
      R__insp.InspectMember(fZaxis, "fZaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarWidth", &fBarWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarOffset", &fBarOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorModelPS", &fColorModelPS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawBorder", &fDrawBorder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptLogx", &fOptLogx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptLogy", &fOptLogy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptLogz", &fOptLogz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptDate", &fOptDate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptStat", &fOptStat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptTitle", &fOptTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptFile", &fOptFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptFit", &fOptFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowEventStatus", &fShowEventStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowEditor", &fShowEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowToolBar", &fShowToolBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumberContours", &fNumberContours);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAttDate", &fAttDate);
      R__insp.InspectMember(fAttDate, "fAttDate.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDateX", &fDateX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDateY", &fDateY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndErrorSize", &fEndErrorSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorX", &fErrorX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFuncColor", &fFuncColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFuncStyle", &fFuncStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFuncWidth", &fFuncWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridColor", &fGridColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridStyle", &fGridStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridWidth", &fGridWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLegendBorderSize", &fLegendBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHatchesLineWidth", &fHatchesLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHatchesSpacing", &fHatchesSpacing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameFillColor", &fFrameFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineColor", &fFrameLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameFillStyle", &fFrameFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineStyle", &fFrameLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineWidth", &fFrameLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameBorderSize", &fFrameBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameBorderMode", &fFrameBorderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistFillColor", &fHistFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistLineColor", &fHistLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistFillStyle", &fHistFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistLineStyle", &fHistLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistLineWidth", &fHistLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistMinimumZero", &fHistMinimumZero);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistTopMargin", &fHistTopMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasPreferGL", &fCanvasPreferGL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasColor", &fCanvasColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasBorderSize", &fCanvasBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasBorderMode", &fCanvasBorderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasDefH", &fCanvasDefH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasDefW", &fCanvasDefW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasDefX", &fCanvasDefX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasDefY", &fCanvasDefY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadColor", &fPadColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadBorderSize", &fPadBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadBorderMode", &fPadBorderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadBottomMargin", &fPadBottomMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadTopMargin", &fPadTopMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadLeftMargin", &fPadLeftMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadRightMargin", &fPadRightMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadGridX", &fPadGridX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadGridY", &fPadGridY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadTickX", &fPadTickX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadTickY", &fPadTickY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPaperSizeX", &fPaperSizeX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPaperSizeY", &fPaperSizeY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScreenFactor", &fScreenFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatColor", &fStatColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatTextColor", &fStatTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatBorderSize", &fStatBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatFont", &fStatFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatFontSize", &fStatFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatStyle", &fStatStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatFormat", &fStatFormat);
      R__insp.InspectMember(fStatFormat, "fStatFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatX", &fStatX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatY", &fStatY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatW", &fStatW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatH", &fStatH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStripDecimals", &fStripDecimals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleAlign", &fTitleAlign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleColor", &fTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleTextColor", &fTitleTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleBorderSize", &fTitleBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleFont", &fTitleFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleFontSize", &fTitleFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleStyle", &fTitleStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleX", &fTitleX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleY", &fTitleY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleW", &fTitleW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleH", &fTitleH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLegoInnerR", &fLegoInnerR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineStyle[30]", fLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeaderPS", &fHeaderPS);
      R__insp.InspectMember(fHeaderPS, "fHeaderPS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePS", &fTitlePS);
      R__insp.InspectMember(fTitlePS, "fTitlePS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitFormat", &fFitFormat);
      R__insp.InspectMember(fFitFormat, "fFitFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPaintTextFormat", &fPaintTextFormat);
      R__insp.InspectMember(fPaintTextFormat, "fPaintTextFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineScalePS", &fLineScalePS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeOffset", &fTimeOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsReading", &fIsReading);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStyle(void *p) {
      return  p ? new(p) ::TStyle : new ::TStyle;
   }
   static void *newArray_TStyle(Long_t nElements, void *p) {
      return p ? new(p) ::TStyle[nElements] : new ::TStyle[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStyle(void *p) {
      delete ((::TStyle*)p);
   }
   static void deleteArray_TStyle(void *p) {
      delete [] ((::TStyle*)p);
   }
   static void destruct_TStyle(void *p) {
      typedef ::TStyle current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStyle

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVirtualX(void *p) {
      return  p ? new(p) ::TVirtualX : new ::TVirtualX;
   }
   static void *newArray_TVirtualX(Long_t nElements, void *p) {
      return p ? new(p) ::TVirtualX[nElements] : new ::TVirtualX[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVirtualX(void *p) {
      delete ((::TVirtualX*)p);
   }
   static void deleteArray_TVirtualX(void *p) {
      delete [] ((::TVirtualX*)p);
   }
   static void destruct_TVirtualX(void *p) {
      typedef ::TVirtualX current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualX

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TBuffer3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBuffer3D.
      TClass *R__cl = ::TBuffer3D::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(), "fNbPnts", &fNbPnts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbSegs", &fNbSegs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbPols", &fNbPols);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPntsCapacity", &fPntsCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSegsCapacity", &fSegsCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolsCapacity", &fPolsCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSections", &fSections);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fID", &fID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransparency", &fTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalFrame", &fLocalFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReflection", &fReflection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalMaster[16]", fLocalMaster);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBBVertex[8][3]", fBBVertex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPnts", &fPnts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSegs", &fSegs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPols", &fPols);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhysicalID", &fPhysicalID);
      TObject::ShowMembers(R__insp);
}

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

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

   TNamed::Streamer(R__b);
}

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

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

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

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

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

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

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

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

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

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

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

   TNamed::Streamer(R__b);
   TAttLine::Streamer(R__b);
   TAttFill::Streamer(R__b);
   TAttMarker::Streamer(R__b);
   TAttText::Streamer(R__b);
}

//______________________________________________________________________________
void TVirtualPS::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualPS.
      TClass *R__cl = ::TVirtualPS::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNByte", &fNByte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLenBuffer", &fLenBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizBuffer", &fSizBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrinted", &fPrinted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStream", &fStream);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuffer", &fBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImplicitCREsc", &fImplicitCREsc);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   TObject::Streamer(R__b);
}

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

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

/********************************************************
* core/base/src/G__Base1.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__Base1();

extern "C" void G__set_cpp_environmentG__Base1() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TApplication.h");
  G__add_compiledheader("TApplicationImp.h");
  G__add_compiledheader("TAtt3D.h");
  G__add_compiledheader("TAttAxis.h");
  G__add_compiledheader("TAttBBox.h");
  G__add_compiledheader("TAttFill.h");
  G__add_compiledheader("TAttLine.h");
  G__add_compiledheader("TAttMarker.h");
  G__add_compiledheader("TAttPad.h");
  G__add_compiledheader("TAttText.h");
  G__add_compiledheader("TBenchmark.h");
  G__add_compiledheader("TBrowser.h");
  G__add_compiledheader("TBrowserImp.h");
  G__add_compiledheader("TBuffer3D.h");
  G__add_compiledheader("TBuffer3DTypes.h");
  G__add_compiledheader("TBuffer.h");
  G__add_compiledheader("TCanvasImp.h");
  G__add_compiledheader("TColor.h");
  G__add_compiledheader("TContextMenu.h");
  G__add_compiledheader("TContextMenuImp.h");
  G__add_compiledheader("TControlBarImp.h");
  G__add_compiledheader("TDatime.h");
  G__add_compiledheader("TDirectory.h");
  G__add_compiledheader("TEnv.h");
  G__add_compiledheader("TError.h");
  G__add_compiledheader("TException.h");
  G__add_compiledheader("TExec.h");
  G__add_compiledheader("TFolder.h");
  G__add_compiledheader("TGuiFactory.h");
  G__add_compiledheader("TInspectorImp.h");
  G__add_compiledheader("TMacro.h");
  G__add_compiledheader("TMathBase.h");
  G__add_compiledheader("TMD5.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMessageHandler.h");
  G__add_compiledheader("TNamed.h");
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TObjString.h");
  G__add_compiledheader("TPluginManager.h");
  G__add_compiledheader("TPoint.h");
  G__add_compiledheader("TPRegexp.h");
  G__add_compiledheader("TProcessID.h");
  G__add_compiledheader("TProcessUUID.h");
  G__add_compiledheader("TQClass.h");
  G__add_compiledheader("TQCommand.h");
  G__add_compiledheader("TQConnection.h");
  G__add_compiledheader("TQObject.h");
  G__add_compiledheader("TRefCnt.h");
  G__add_compiledheader("TRef.h");
  G__add_compiledheader("TRegexp.h");
  G__add_compiledheader("TRemoteObject.h");
  G__add_compiledheader("TROOT.h");
  G__add_compiledheader("TRootIOCtor.h");
  G__add_compiledheader("TStopwatch.h");
  G__add_compiledheader("TStorage.h");
  G__add_compiledheader("TString.h");
  G__add_compiledheader("TStringLong.h");
  G__add_compiledheader("TStyle.h");
  G__add_compiledheader("TSysEvtHandler.h");
  G__add_compiledheader("TSystemDirectory.h");
  G__add_compiledheader("TSystemFile.h");
  G__add_compiledheader("TSystem.h");
  G__add_compiledheader("TTask.h");
  G__add_compiledheader("TTime.h");
  G__add_compiledheader("TTimer.h");
  G__add_compiledheader("TUUID.h");
  G__add_compiledheader("TVersionCheck.h");
  G__add_compiledheader("TVirtualFFT.h");
  G__add_compiledheader("TVirtualGL.h");
  G__add_compiledheader("TVirtualPadEditor.h");
  G__add_compiledheader("TVirtualPad.h");
  G__add_compiledheader("TVirtualPadPainter.h");
  G__add_compiledheader("TVirtualPS.h");
  G__add_compiledheader("TVirtualViewer3D.h");
  G__cpp_reset_tagtableG__Base1();
}
#include <new>
extern "C" int G__cpp_dllrevG__Base1() { return(30051515); }

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

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

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

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

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

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

static int G__G__Base1_7_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TBuffer*) G__getstructoffset())->SetBuffer((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (ReAllocCharFun_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TBuffer*) G__getstructoffset())->SetBuffer((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->SetBuffer((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TBuffer*) G__getstructoffset())->SetBuffer((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteBuf((void*) 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__Base1_7_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TBuffer*) G__getstructoffset())->ReadString((char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Base1_7_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TBuffer*) G__getstructoffset())->GetMappedObject((UInt_t) G__int(libp->para[0]), libp->para[1].ref ? *(void**) libp->para[1].ref : *(void**) (void*) (&G__Mlong(libp->para[1]))
, libp->para[2].ref ? *(TClass**) libp->para[2].ref : *(TClass**) (void*) (&G__Mlong(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 115, (long) ((TBuffer*) G__getstructoffset())->ReadVersion((UInt_t*) G__int(libp->para[0]), (UInt_t*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 115, (long) ((TBuffer*) G__getstructoffset())->ReadVersion((UInt_t*) G__int(libp->para[0]), (UInt_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 115, (long) ((TBuffer*) G__getstructoffset())->ReadVersion((UInt_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((TBuffer*) G__getstructoffset())->ReadVersion());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TBuffer*) G__getstructoffset())->ClassMember((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]));
      G__setnull(result7);
      break;
   case 3:
      ((TBuffer*) G__getstructoffset())->ClassMember((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->ClassMember((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TBuffer*) G__getstructoffset())->ClassMember((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const TBuffer*) G__getstructoffset())->GetPidOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadWithFactor((Float_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadWithNbits((Float_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__Base1_7_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadWithFactor((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadWithNbits((Double_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__Base1_7_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Bool_t**) libp->para[0].ref : *(Bool_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Char_t**) libp->para[0].ref : *(Char_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(UChar_t**) libp->para[0].ref : *(UChar_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Short_t**) libp->para[0].ref : *(Short_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(UShort_t**) libp->para[0].ref : *(UShort_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Int_t**) libp->para[0].ref : *(Int_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(UInt_t**) libp->para[0].ref : *(UInt_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Long_t**) libp->para[0].ref : *(Long_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(ULong_t**) libp->para[0].ref : *(ULong_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Long64_t**) libp->para[0].ref : *(Long64_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(ULong64_t**) libp->para[0].ref : *(ULong64_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Float_t**) libp->para[0].ref : *(Float_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArray(libp->para[0].ref ? *(Double_t**) libp->para[0].ref : *(Double_t**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArrayFloat16(libp->para[0].ref ? *(Float_t**) libp->para[0].ref : *(Float_t**) (void*) (&G__Mlong(libp->para[0])), (TStreamerElement*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArrayFloat16(libp->para[0].ref ? *(Float_t**) libp->para[0].ref : *(Float_t**) (void*) (&G__Mlong(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArrayDouble32(libp->para[0].ref ? *(Double_t**) libp->para[0].ref : *(Double_t**) (void*) (&G__Mlong(libp->para[0])), (TStreamerElement*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadArrayDouble32(libp->para[0].ref ? *(Double_t**) libp->para[0].ref : *(Double_t**) (void*) (&G__Mlong(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadStaticArrayFloat16((Float_t*) G__int(libp->para[0]), (TStreamerElement*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadStaticArrayFloat16((Float_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadStaticArrayDouble32((Double_t*) G__int(libp->para[0]), (TStreamerElement*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadStaticArrayDouble32((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Bool_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__Base1_7_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Char_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_7_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((UChar_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__Base1_7_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Short_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((UShort_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__Base1_7_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((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__Base1_7_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((UInt_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__Base1_7_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Long_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((ULong_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__Base1_7_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Long64_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__Base1_7_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((ULong64_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__Base1_7_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Float_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__Base1_7_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFastArray((Double_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__Base1_7_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TBuffer*) G__getstructoffset())->ReadFastArrayFloat16((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TStreamerElement*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->ReadFastArrayFloat16((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Base1_7_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TBuffer*) G__getstructoffset())->ReadFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (TMemberStreamer*) G__int(libp->para[4]), (TClass*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TBuffer*) G__getstructoffset())->ReadFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (TMemberStreamer*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TBuffer*) G__getstructoffset())->ReadFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TBuffer*) G__getstructoffset())->ReadFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->ReadFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const Bool_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__Base1_7_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const Char_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const UChar_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__Base1_7_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const Short_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const UShort_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__Base1_7_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const Int_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const UInt_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__Base1_7_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const Long_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const ULong_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__Base1_7_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const Long64_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__Base1_7_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((const ULong64_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__Base1_7_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((Float_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__Base1_7_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteArray((Double_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__Base1_7_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TBuffer*) G__getstructoffset())->WriteArrayFloat16((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TStreamerElement*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->WriteArrayFloat16((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_7_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const Bool_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__Base1_7_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const Char_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_7_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const UChar_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__Base1_7_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const Short_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const UShort_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__Base1_7_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const Int_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const UInt_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__Base1_7_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const Long_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const ULong_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__Base1_7_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const Long64_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__Base1_7_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((const ULong64_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__Base1_7_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((Float_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__Base1_7_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteFastArray((Double_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__Base1_7_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TBuffer*) G__getstructoffset())->WriteFastArrayFloat16((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TStreamerElement*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->WriteFastArrayFloat16((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Base1_7_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->WriteFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (TMemberStreamer*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->WriteFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->WriteFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->WriteFastArray((void**) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_7_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TBuffer*) G__getstructoffset())->StreamObject((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->StreamObject((void*) 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__Base1_7_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TBuffer*) G__getstructoffset())->StreamObject((void*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TBuffer*) G__getstructoffset())->StreamObject((void*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_7_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadBool(*(Bool_t*) G__Boolref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadChar(*(Char_t*) G__Charref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadUChar(*(UChar_t*) G__UCharref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadShort(*(Short_t*) G__Shortref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadUShort(*(UShort_t*) G__UShortref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadInt(*(Int_t*) G__Intref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadUInt(*(UInt_t*) G__UIntref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadLong(*(Long_t*) G__Longref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadULong(*(ULong_t*) G__ULongref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadLong64(*(Long64_t*) G__Longlongref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadULong64(*(ULong64_t*) G__ULonglongref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadFloat(*(Float_t*) G__Floatref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_7_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->ReadDouble(*(Double_t*) G__Doubleref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_7_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer*) G__getstructoffset())->WriteULong64((ULong64_t) G__ULonglong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Base1_7_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TBuffer*) G__getstructoffset())->GetTRefExecId());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Base1_7_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadClones((TClonesArray*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Version_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Base1_7_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadClassBuffer((TClass*) G__int(libp->para[0]), (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]), (TClass*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 105, (long) ((TBuffer*) G__getstructoffset())->ReadClassBuffer((TClass*) G__int(libp->para[0]), (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])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_8_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TUUID* pobj;
         const TUUID xobj = ((const TDirectory*) G__getstructoffset())->GetUUID();
         pobj = new TUUID(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__Base1_8_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TDirectory*) G__getstructoffset())->IsModified());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_8_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TDirectory*) G__getstructoffset())->WriteObjectAny((void*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TDirectory*) G__getstructoffset())->WriteObjectAny((void*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TDirectory*) G__getstructoffset())->WriteObjectAny((void*) G__int(libp->para[0]), (TClass*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Base1_8_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDirectory::DecodeNameCycle((const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, *(Short_t*) G__Shortref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_8_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDirectory::EncodeNameCycle((char*) 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__Base1_8_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDirectory::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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


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

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

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

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

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


/* ROOT */
static int G__G__Base1_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__Base1_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__Base1_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__Base1_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__Base1_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__Base1_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__Base1_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) ;
}

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

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


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

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

static int G__G__Base1_77_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (TBrowserImp*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TBrowser(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (TBrowserImp*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (TBrowserImp*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBrowser(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (TBrowserImp*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBrowser(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Base1_77_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) 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 TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_77_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) 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])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Option_t*) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) 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])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Option_t*) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) 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])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TBrowser(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) 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])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_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__Base1LN_TBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_77_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 108, (long) ((TBrowser*) G__getstructoffset())->ExecPlugin((const char*) 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])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 108, (long) ((TBrowser*) G__getstructoffset())->ExecPlugin((const char*) 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])));
      break;
   case 3:
      G__letint(result7, 108, (long) ((TBrowser*) G__getstructoffset())->ExecPlugin((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, 108, (long) ((TBrowser*) G__getstructoffset())->ExecPlugin((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TBrowser*) G__getstructoffset())->ExecPlugin((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 108, (long) ((TBrowser*) G__getstructoffset())->ExecPlugin());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_77_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowser*) G__getstructoffset())->SetStatusText((const char*) 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__Base1_77_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowser*) G__getstructoffset())->StartEmbedding((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__Base1_77_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TBrowser*) G__getstructoffset())->StopEmbedding((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TBrowser*) G__getstructoffset())->StopEmbedding();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

static int G__G__Base1_116_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 108, (long) ((TApplication*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 108, (long) ((TApplication*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TApplication*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_116_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 108, (long) ((TApplication*) G__getstructoffset())->ProcessFile((const char*) 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, 108, (long) ((TApplication*) G__getstructoffset())->ProcessFile((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TApplication*) G__getstructoffset())->ProcessFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_116_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TApplication*) G__getstructoffset())->SetIdleTimer((UInt_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__Base1_116_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TApplication*) G__getstructoffset())->RemoveIdleTimer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Base1_116_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TApplication*) G__getstructoffset())->ExitOnException((TApplication::EExitOnException) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TApplication*) G__getstructoffset())->ExitOnException());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_116_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TApplication::CreateApplication();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_116_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TApplication::NeedGraphicsLibs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

static int G__G__Base1_120_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttAxis*) G__getstructoffset())->GetLabelOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttAxis*) G__getstructoffset())->GetLabelSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttAxis*) G__getstructoffset())->GetTitleOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttAxis*) G__getstructoffset())->GetTitleSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttAxis*) G__getstructoffset())->GetTickLength());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Base1_120_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttAxis*) G__getstructoffset())->SaveAttributes(*(ostream*) libp->para[0].ref, (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__Base1_120_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TAttAxis*) G__getstructoffset())->SetNdivisions((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TAttAxis*) G__getstructoffset())->SetNdivisions((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttAxis*) G__getstructoffset())->SetNdivisions();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Base1_120_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttAxis*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttAxis*) G__getstructoffset())->SetLabelOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttAxis*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttAxis*) G__getstructoffset())->SetLabelSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttAxis*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttAxis*) G__getstructoffset())->SetTickLength();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttAxis*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttAxis*) G__getstructoffset())->SetTitleOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_120_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttAxis*) G__getstructoffset())->SetTitleSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttAxis*) G__getstructoffset())->SetTitleSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Base1_123_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TAttLine(
(Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
, (Width_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TAttLine(
(Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
, (Width_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__Base1LN_TAttLine));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Base1_123_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TAttLine*) G__getstructoffset())->DistancetoLine((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Base1_123_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TAttLine::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TAttLine::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TAttLine*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttLine*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttLine*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttLine*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttLine::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttLine::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttLine::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_123_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttLine::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_123_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TAttLine* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TAttLine(*(TAttLine*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttLine));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TAttLine G__TTAttLine;
static int G__G__Base1_123_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TAttLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TAttLine*) (soff+(sizeof(TAttLine)*i)))->~G__TTAttLine();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TAttLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TAttLine*) (soff))->~G__TTAttLine();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_123_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttLine* dest = (TAttLine*) G__getstructoffset();
   *dest = *(TAttLine*) libp->para[0].ref;
   const TAttLine& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TAttMarker */
static int G__G__Base1_125_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAttMarker[n];
     } else {
       p = new((void*) gvp) TAttMarker[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAttMarker;
     } else {
       p = new((void*) gvp) TAttMarker;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TAttMarker(
(Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
, (Size_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TAttMarker(
(Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
, (Size_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TAttMarker*) G__getstructoffset())->Copy(*(TAttMarker*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttMarker*) G__getstructoffset())->GetMarkerColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttMarker*) G__getstructoffset())->GetMarkerStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttMarker*) G__getstructoffset())->GetMarkerSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttMarker*) G__getstructoffset())->Modify();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttMarker*) G__getstructoffset())->ResetAttMarker((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttMarker*) G__getstructoffset())->ResetAttMarker();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TAttMarker*) G__getstructoffset())->SaveMarkerAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TAttMarker*) G__getstructoffset())->SaveMarkerAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TAttMarker*) G__getstructoffset())->SaveMarkerAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TAttMarker*) G__getstructoffset())->SaveMarkerAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttMarker*) G__getstructoffset())->SetMarkerAttributes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttMarker*) G__getstructoffset())->SetMarkerColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttMarker*) G__getstructoffset())->SetMarkerColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttMarker*) G__getstructoffset())->SetMarkerStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttMarker*) G__getstructoffset())->SetMarkerStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttMarker*) G__getstructoffset())->SetMarkerSize((Size_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttMarker*) G__getstructoffset())->SetMarkerSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TAttMarker::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttMarker::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TAttMarker::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TAttMarker::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TAttMarker*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttMarker*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttMarker*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttMarker*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttMarker::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttMarker::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttMarker::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_125_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttMarker::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_125_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TAttMarker* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TAttMarker(*(TAttMarker*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TAttMarker G__TTAttMarker;
static int G__G__Base1_125_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TAttMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TAttMarker*) (soff+(sizeof(TAttMarker)*i)))->~G__TTAttMarker();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TAttMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TAttMarker*) (soff))->~G__TTAttMarker();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_125_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttMarker* dest = (TAttMarker*) G__getstructoffset();
   *dest = *(TAttMarker*) libp->para[0].ref;
   const TAttMarker& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TAttPad */
static int G__G__Base1_127_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttPad* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAttPad[n];
     } else {
       p = new((void*) gvp) TAttPad[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAttPad;
     } else {
       p = new((void*) gvp) TAttPad;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttPad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TAttPad*) G__getstructoffset())->Copy(*(TAttPad*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetBottomMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetLeftMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetRightMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetTopMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetAfile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetXfile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetYfile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetAstat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetXstat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttPad*) G__getstructoffset())->GetYstat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttPad*) G__getstructoffset())->GetFrameFillColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttPad*) G__getstructoffset())->GetFrameLineColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttPad*) G__getstructoffset())->GetFrameFillStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttPad*) G__getstructoffset())->GetFrameLineStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttPad*) G__getstructoffset())->GetFrameLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttPad*) G__getstructoffset())->GetFrameBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TAttPad*) G__getstructoffset())->GetFrameBorderMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TAttPad*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TAttPad*) G__getstructoffset())->Print();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->ResetAttPad((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->ResetAttPad();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetBottomMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetLeftMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetRightMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetTopMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetMargin((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetAfile((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetXfile((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetYfile((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetAstat((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetXstat((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->SetYstat((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameFillColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameFillColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameLineColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameFillStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameFillStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameLineStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameLineStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameLineWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameLineWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttPad*) G__getstructoffset())->SetFrameBorderMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttPad*) G__getstructoffset())->SetFrameBorderMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TAttPad::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttPad::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TAttPad::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TAttPad::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TAttPad*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttPad*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttPad::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttPad::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttPad::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_127_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttPad::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_127_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TAttPad* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TAttPad(*(TAttPad*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttPad));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TAttPad G__TTAttPad;
static int G__G__Base1_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TAttPad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TAttPad*) (soff+(sizeof(TAttPad)*i)))->~G__TTAttPad();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TAttPad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TAttPad*) (soff))->~G__TTAttPad();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_127_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttPad* dest = (TAttPad*) G__getstructoffset();
   *dest = *(TAttPad*) libp->para[0].ref;
   const TAttPad& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TAttText */
static int G__G__Base1_128_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttText* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAttText[n];
     } else {
       p = new((void*) gvp) TAttText[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAttText;
     } else {
       p = new((void*) gvp) TAttText;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttText* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TAttText(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Color_t) G__int(libp->para[2]), (Style_t) G__int(libp->para[3])
, (Float_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TAttText(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Color_t) G__int(libp->para[2]), (Style_t) G__int(libp->para[3])
, (Float_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TAttText*) G__getstructoffset())->Copy(*(TAttText*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttText*) G__getstructoffset())->GetTextAlign());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttText*) G__getstructoffset())->GetTextAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttText*) G__getstructoffset())->GetTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TAttText*) G__getstructoffset())->GetTextFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TAttText*) G__getstructoffset())->GetTextSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttText*) G__getstructoffset())->Modify();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttText*) G__getstructoffset())->ResetAttText((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttText*) G__getstructoffset())->ResetAttText();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TAttText*) G__getstructoffset())->SaveTextAttributes(
*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Float_t) G__double(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TAttText*) G__getstructoffset())->SaveTextAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TAttText*) G__getstructoffset())->SaveTextAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TAttText*) G__getstructoffset())->SaveTextAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TAttText*) G__getstructoffset())->SaveTextAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TAttText*) G__getstructoffset())->SaveTextAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttText*) G__getstructoffset())->SetTextAttributes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttText*) G__getstructoffset())->SetTextAlign((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttText*) G__getstructoffset())->SetTextAlign();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttText*) G__getstructoffset())->SetTextAngle((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttText*) G__getstructoffset())->SetTextAngle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttText*) G__getstructoffset())->SetTextColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttText*) G__getstructoffset())->SetTextColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttText*) G__getstructoffset())->SetTextFont((Font_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttText*) G__getstructoffset())->SetTextFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAttText*) G__getstructoffset())->SetTextSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAttText*) G__getstructoffset())->SetTextSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttText*) G__getstructoffset())->SetTextSizePixels((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TAttText::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttText::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TAttText::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TAttText::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TAttText*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttText*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttText*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttText::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttText::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAttText::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_128_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAttText::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_128_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TAttText* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TAttText(*(TAttText*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TAttText));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TAttText G__TTAttText;
static int G__G__Base1_128_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TAttText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TAttText*) (soff+(sizeof(TAttText)*i)))->~G__TTAttText();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TAttText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TAttText*) (soff))->~G__TTAttText();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_128_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAttText* dest = (TAttText*) G__getstructoffset();
   *dest = *(TAttText*) libp->para[0].ref;
   const TAttText& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBenchmark */
static int G__G__Base1_131_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBenchmark* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBenchmark[n];
     } else {
       p = new((void*) gvp) TBenchmark[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBenchmark;
     } else {
       p = new((void*) gvp) TBenchmark;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBenchmark));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TBenchmark*) G__getstructoffset())->GetBench((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TBenchmark*) G__getstructoffset())->GetCpuTime((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TBenchmark*) G__getstructoffset())->GetRealTime((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBenchmark*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBenchmark*) G__getstructoffset())->Show((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBenchmark*) G__getstructoffset())->Start((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBenchmark*) G__getstructoffset())->Stop((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBenchmark*) G__getstructoffset())->Summary(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBenchmark::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBenchmark::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBenchmark::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBenchmark::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBenchmark*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBenchmark::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBenchmark::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBenchmark::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_131_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBenchmark::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBenchmark G__TTBenchmark;
static int G__G__Base1_131_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[] (TBenchmark*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBenchmark*) (soff+(sizeof(TBenchmark)*i)))->~G__TTBenchmark();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBenchmark*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBenchmark*) (soff))->~G__TTBenchmark();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBrowserImp */
static int G__G__Base1_133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowserImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserImp((TBrowser*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TBrowserImp((TBrowser*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TBrowserImp[n];
       } else {
         p = new((void*) gvp) TBrowserImp[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TBrowserImp;
       } else {
         p = new((void*) gvp) TBrowserImp;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowserImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserImp(
(TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBrowserImp(
(TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserImp(
(TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBrowserImp(
(TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowserImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserImp(
(TBrowser*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBrowserImp(
(TBrowser*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserImp(
(TBrowser*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBrowserImp(
(TBrowser*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (const char*) 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__Base1_133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TBrowserImp*) G__getstructoffset())->AddCheckBox((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TBrowserImp*) G__getstructoffset())->AddCheckBox((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TBrowserImp*) G__getstructoffset())->CheckObjectItem((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TBrowserImp*) G__getstructoffset())->CheckObjectItem((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->RemoveCheckBox((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->BrowseObj((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBrowserImp*) G__getstructoffset())->Browser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->ExecuteDefaultAction((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->Iconify();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->RecursiveRemove((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TBrowserImp*) G__getstructoffset())->Refresh((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TBrowserImp*) G__getstructoffset())->Refresh();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TBrowserImp*) G__getstructoffset())->SetDrawOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TBrowserImp*) G__getstructoffset())->SetDrawOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBrowserImp*) G__getstructoffset())->GetDrawOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TBrowserImp*) G__getstructoffset())->ExecPlugin((const char*) 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])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->SetStatusText((const char*) 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__Base1_133_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->StartEmbedding((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__Base1_133_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->StopEmbedding((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBrowserImp*) G__getstructoffset())->GetMainFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBrowserImp*) G__getstructoffset())->GetBrowser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->SetBrowser((TBrowser*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBrowserImp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBrowserImp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBrowserImp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBrowserImp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBrowserImp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserImp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBrowserImp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBrowserImp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBrowserImp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_133_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBrowserImp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBrowserImp G__TTBrowserImp;
static int G__G__Base1_133_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TBrowserImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBrowserImp*) (soff+(sizeof(TBrowserImp)*i)))->~G__TTBrowserImp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBrowserImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBrowserImp*) (soff))->~G__TTBrowserImp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TContextMenu */
static int G__G__Base1_134_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TContextMenu* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TContextMenu((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TContextMenu((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 TContextMenu((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TContextMenu((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__Base1LN_TContextMenu));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Action((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__Base1_134_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Action((TObject*) G__int(libp->para[0]), (TToggle*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Action((TClassMenuItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Action((TMethod*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Action((TToggle*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TContextMenu*) G__getstructoffset())->CreateArgumentTitle((TMethodArg*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TContextMenu*) G__getstructoffset())->CreateDialogTitle((TObject*) G__int(libp->para[0]), (TFunction*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TContextMenu*) G__getstructoffset())->CreatePopupTitle((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Execute((TObject*) G__int(libp->para[0]), (TFunction*) 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__Base1_134_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Execute((TObject*) G__int(libp->para[0]), (TFunction*) G__int(libp->para[1])
, (TObjArray*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Execute((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Execute((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetBrowser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetContextMenuImp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetSelectedCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetSelectedMethod());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetSelectedObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetCalledObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetSelectedMenuItem());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TContextMenu*) G__getstructoffset())->GetSelectedPad());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TContextMenu*) G__getstructoffset())->Popup((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3])
, (TVirtualPad*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TContextMenu*) G__getstructoffset())->Popup((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TContextMenu*) G__getstructoffset())->Popup((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->Popup((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2]), (TBrowser*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetCanvas((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetBrowser((TBrowser*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetMethod((TFunction*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetCalledObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetSelectedMenuItem((TClassMenuItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->SetPad((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TContextMenu::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TContextMenu::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TContextMenu::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TContextMenu::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenu*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TContextMenu::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TContextMenu::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TContextMenu::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_134_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TContextMenu::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TContextMenu G__TTContextMenu;
static int G__G__Base1_134_0_50(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[] (TContextMenu*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TContextMenu*) (soff+(sizeof(TContextMenu)*i)))->~G__TTContextMenu();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TContextMenu*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TContextMenu*) (soff))->~G__TTContextMenu();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBuffer3D */
static int G__G__Base1_137_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TBuffer3D::GetCSLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBuffer3D::IncCSLevel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TBuffer3D::DecCSLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBuffer3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBuffer3D(
(Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TBuffer3D((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBuffer3D((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TBuffer3D((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer3D*) G__getstructoffset())->SetSectionsValid((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer3D*) G__getstructoffset())->ClearSectionsValid();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TBuffer3D*) G__getstructoffset())->SectionsValid((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TBuffer3D*) G__getstructoffset())->GetSections((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer3D*) G__getstructoffset())->SetLocalMasterIdentity();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer3D*) G__getstructoffset())->SetAABoundingBox((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TBuffer3D*) G__getstructoffset())->SetRawSizes((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TBuffer3D*) G__getstructoffset())->NbPnts());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TBuffer3D*) G__getstructoffset())->NbSegs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TBuffer3D*) G__getstructoffset())->NbPols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TBuffer3D*) G__getstructoffset())->Type());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBuffer3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBuffer3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBuffer3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBuffer3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBuffer3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBuffer3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBuffer3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBuffer3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_137_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBuffer3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBuffer3D G__TTBuffer3D;
static int G__G__Base1_137_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[] (TBuffer3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBuffer3D*) (soff+(sizeof(TBuffer3D)*i)))->~G__TTBuffer3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBuffer3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBuffer3D*) (soff))->~G__TTBuffer3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TCanvasImp */
static int G__G__Base1_147_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TCanvasImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TCanvasImp((TCanvas*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TCanvasImp((TCanvas*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TCanvasImp[n];
       } else {
         p = new((void*) gvp) TCanvasImp[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TCanvasImp;
       } else {
         p = new((void*) gvp) TCanvasImp;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TCanvasImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TCanvasImp(
(TCanvas*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TCanvasImp(
(TCanvas*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TCanvasImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TCanvasImp(
(TCanvas*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TCanvasImp(
(TCanvas*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_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__Base1LN_TCanvasImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TCanvasImp*) G__getstructoffset())->Canvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->Close();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->ForceUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TCanvasImp*) G__getstructoffset())->GetWindowGeometry(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2]), *(UInt_t*) G__UIntref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->Iconify();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TCanvasImp*) G__getstructoffset())->InitWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TCanvasImp*) G__getstructoffset())->SetStatusText((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TCanvasImp*) G__getstructoffset())->SetStatusText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TCanvasImp*) G__getstructoffset())->SetStatusText();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->SetWindowPosition((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__Base1_147_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->SetWindowSize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->SetWindowTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->SetCanvasSize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TCanvasImp*) G__getstructoffset())->ShowMenuBar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TCanvasImp*) G__getstructoffset())->ShowMenuBar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TCanvasImp*) G__getstructoffset())->ShowStatusBar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TCanvasImp*) G__getstructoffset())->ShowStatusBar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->RaiseWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->ReallyDelete();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TCanvasImp*) G__getstructoffset())->ShowEditor((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TCanvasImp*) G__getstructoffset())->ShowEditor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TCanvasImp*) G__getstructoffset())->ShowToolBar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TCanvasImp*) G__getstructoffset())->ShowToolBar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TCanvasImp*) G__getstructoffset())->ShowToolTips((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TCanvasImp*) G__getstructoffset())->ShowToolTips();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCanvasImp*) G__getstructoffset())->HasEditor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCanvasImp*) G__getstructoffset())->HasMenuBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCanvasImp*) G__getstructoffset())->HasStatusBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCanvasImp*) G__getstructoffset())->HasToolBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCanvasImp*) G__getstructoffset())->HasToolTips());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TCanvasImp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TCanvasImp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TCanvasImp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCanvasImp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TCanvasImp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCanvasImp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TCanvasImp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TCanvasImp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TCanvasImp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_147_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TCanvasImp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TCanvasImp G__TTCanvasImp;
static int G__G__Base1_147_0_45(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[] (TCanvasImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TCanvasImp*) (soff+(sizeof(TCanvasImp)*i)))->~G__TTCanvasImp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TCanvasImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TCanvasImp*) (soff))->~G__TTCanvasImp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TColor */
static int G__G__Base1_150_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TColor[n];
     } else {
       p = new((void*) gvp) TColor[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TColor;
     } else {
       p = new((void*) gvp) TColor;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TColor(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Float_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TColor(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Float_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TColor(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TColor(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TColor(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TColor(
(Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TColor(*(TColor*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TColor(*(TColor*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TColor*) G__getstructoffset())->AsHexString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::CreateColorWheel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::CreateColorsGray();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::CreateColorsCircle((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UChar_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::CreateColorsRectangle((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UChar_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::CreateGradientColorTable((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColorPalette((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetNumberOfColors());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TColor*) G__getstructoffset())->GetRGB(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TColor*) G__getstructoffset())->GetHLS(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TColor*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TColor*) G__getstructoffset())->GetPixel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetRed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetGreen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetBlue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetHue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetLight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetSaturation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetAlpha());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TColor*) G__getstructoffset())->GetGrayscale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TColor*) G__getstructoffset())->SetRGB((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::InitializeColors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::HLS2RGB((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::HLS2RGB((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::HLStoRGB((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::HSV2RGB((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::RGB2HLS((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::RGB2HLS((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::RGBtoHLS((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::RGB2HSV((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColor((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColor((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColor((ULong_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColorBright((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::GetColorDark((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TColor::Number2Pixel((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TColor::RGB2Pixel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TColor::RGB2Pixel((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::Pixel2RGB((ULong_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::Pixel2RGB((ULong_t) G__int(libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TColor::PixelAsHexString((ULong_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::SaveColor(*(ostream*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TColor::IsGrayscale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TColor::SetGrayscale((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TColor::SetGrayscale();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::SetPalette((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__Base1_150_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TColor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TColor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TColor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TColor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TColor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TColor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TColor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_150_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TColor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TColor G__TTColor;
static int G__G__Base1_150_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TColor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TColor*) (soff+(sizeof(TColor)*i)))->~G__TTColor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TColor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TColor*) (soff))->~G__TTColor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_150_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TColor* dest = (TColor*) G__getstructoffset();
   *dest = *(TColor*) libp->para[0].ref;
   const TColor& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TContextMenuImp */
static int G__G__Base1_152_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TContextMenuImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TContextMenuImp((TContextMenu*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TContextMenuImp((TContextMenu*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TContextMenuImp[n];
       } else {
         p = new((void*) gvp) TContextMenuImp[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TContextMenuImp;
       } else {
         p = new((void*) gvp) TContextMenuImp;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TContextMenuImp*) G__getstructoffset())->GetContextMenu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenuImp*) G__getstructoffset())->Dialog((TObject*) G__int(libp->para[0]), (TFunction*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenuImp*) G__getstructoffset())->Dialog((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__Base1_152_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenuImp*) G__getstructoffset())->DisplayPopup((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__Base1_152_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TContextMenuImp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TContextMenuImp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TContextMenuImp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TContextMenuImp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TContextMenuImp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenuImp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenuImp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TContextMenuImp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TContextMenuImp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TContextMenuImp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TContextMenuImp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TContextMenuImp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TContextMenuImp G__TTContextMenuImp;
static int G__G__Base1_152_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TContextMenuImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TContextMenuImp*) (soff+(sizeof(TContextMenuImp)*i)))->~G__TTContextMenuImp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TContextMenuImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TContextMenuImp*) (soff))->~G__TTContextMenuImp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualPad */
static int G__G__Base1_154_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->AbsCoordinates((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TVirtualPad*) G__getstructoffset())->AbsPixeltoX((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TVirtualPad*) G__getstructoffset())->AbsPixeltoY((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->AddExec((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__Base1_154_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->cd((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->cd());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->Close();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->CopyPixmap();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->CopyPixmaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->DeleteExec((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TVirtualPad*) G__getstructoffset())->Divide((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TVirtualPad*) G__getstructoffset())->Divide((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->Divide((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualPad*) G__getstructoffset())->Divide((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPad*) G__getstructoffset())->Divide((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->Divide();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPad*) G__getstructoffset())->DrawClassObject((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPad*) G__getstructoffset())->DrawClassObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->DrawFrame((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->DrawFrame((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->ExecuteEventAxis((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TAxis*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPad*) G__getstructoffset())->GetBorderMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPad*) G__getstructoffset())->GetBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetCanvasID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetCanvasImp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetVirtCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetEventX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetEventY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPad*) G__getstructoffset())->GetHighLightColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->GetRange(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->GetRangeAxis(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->GetPadPar(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetXlowNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetYlowNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetWNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetHNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TVirtualPad*) G__getstructoffset())->GetWw());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TVirtualPad*) G__getstructoffset())->GetWh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetAbsXlowNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetAbsYlowNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetAbsWNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetAbsHNDC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetAspectRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetUxmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetUymin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetUxmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetUymax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->GetGridx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->GetGridy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetTickx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetTicky());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetX1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetX2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetY1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->GetY2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetListOfPrimitives());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetListOfExecs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetPrimitive((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetPad((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetPadPointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetPadSave());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetSelectedPad());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetView());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetLogx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetLogy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetLogz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetMother());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetPadPaint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->GetPixmapID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPad*) G__getstructoffset())->GetView3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->HasCrosshair());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPad*) G__getstructoffset())->HighLight((Color_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPad*) G__getstructoffset())->HighLight((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->HighLight();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->HasFixedAspectRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->IsBatch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->IsBeingResized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->IsEditable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->IsModified());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->IsRetained());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->IsVertical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->Modified((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->Modified();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->OpaqueMoving());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->OpaqueResizing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->PadtoX((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->PadtoY((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintBorderPS(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TVirtualPad*) G__getstructoffset())->PaintBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintFillArea((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintFillArea((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintFillArea((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintFillArea((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintPadFrame((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintLineNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintLine3D((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintLine3D((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLine((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLine((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLine3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLineNDC((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyLineNDC((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualPad*) G__getstructoffset())->PaintPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintText((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->PaintTextNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TVirtualPad*) G__getstructoffset())->PixeltoX((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TVirtualPad*) G__getstructoffset())->PixeltoY((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->Print((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->Range((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->RangeAxis((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->RedrawAxis((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->RedrawAxis();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->ResetView3D((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->ResetView3D();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->ResizePad((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->ResizePad();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetBatch((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetBatch();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetBorderMode((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetBorderSize((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetCanvas((TCanvas*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetCanvasSize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetCrosshair((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetCrosshair();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetCursor((ECursor) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetDoubleBuffer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetDoubleBuffer();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetEditable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetEditable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetFixedAspectRatio((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetFixedAspectRatio();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPad*) G__getstructoffset())->SetGrid((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetGrid((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetGrid();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetGridx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetGridx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetGridy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetGridy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetLogx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetLogx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetLogy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetLogy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetLogz((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetLogz();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      ((TVirtualPad*) G__getstructoffset())->SetPad(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Color_t) G__int(libp->para[6]), (Short_t) G__int(libp->para[7])
, (Short_t) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TVirtualPad*) G__getstructoffset())->SetPad(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Color_t) G__int(libp->para[6]), (Short_t) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TVirtualPad*) G__getstructoffset())->SetPad(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Color_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TVirtualPad*) G__getstructoffset())->SetPad((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetPad((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetAttFillPS((Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetAttLinePS((Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
, (Width_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetAttMarkerPS((Color_t) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
, (Size_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetAttTextPS((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Color_t) G__int(libp->para[2]), (Style_t) G__int(libp->para[3])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetSelected((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPad*) G__getstructoffset())->SetTicks((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetTicks((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetTicks();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetTickx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetTickx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetTicky((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetTicky();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetTitle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetTheta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetTheta();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetPhi();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPad*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetVertical((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetVertical();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->SetView((TView*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->SetView();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetViewer3D((TVirtualViewer3D*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->WaitPrimitive((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->WaitPrimitive((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->WaitPrimitive());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->Update();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->UtoAbsPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->VtoAbsPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->UtoPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->VtoPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->XtoAbsPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->YtoAbsPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->XtoPad((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVirtualPad*) G__getstructoffset())->YtoPad((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->XtoPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPad*) G__getstructoffset())->YtoPixel((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->CreateToolTip((TBox*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->DeleteToolTip((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->ResetToolTip((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->CloseToolTip((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->GetViewer3D((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVirtualPad*) G__getstructoffset())->GetViewer3D());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPad*) G__getstructoffset())->HasViewer3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPad*) G__getstructoffset())->ReleaseViewer3D((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPad*) G__getstructoffset())->ReleaseViewer3D();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualPad*) G__getstructoffset())->GetGLDevice());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->SetCopyGLDevice((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVirtualPad*& obj = TVirtualPad::Pad();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualPad::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPad::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualPad::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPad::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPad*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPad::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPad::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPad::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_154_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPad::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualPad G__TTVirtualPad;
static int G__G__Base1_154_0_191(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[] (TVirtualPad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualPad*) (soff+(sizeof(TVirtualPad)*i)))->~G__TTVirtualPad();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualPad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualPad*) (soff))->~G__TTVirtualPad();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TControlBarImp */
static int G__G__Base1_159_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TControlBarImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TControlBarImp((TControlBar*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TControlBarImp((TControlBar*) 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 TControlBarImp((TControlBar*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TControlBarImp((TControlBar*) 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__Base1LN_TControlBarImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TControlBarImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TControlBarImp(
(TControlBar*) 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]));
   } else {
     p = new((void*) gvp) TControlBarImp(
(TControlBar*) 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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TControlBarImp*) G__getstructoffset())->GetControlBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TControlBarImp*) G__getstructoffset())->GetClicked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->Create();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->SetFont((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->SetTextColor((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->SetButtonState((const char*) 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__Base1_159_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->SetButtonWidth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TControlBarImp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TControlBarImp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TControlBarImp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TControlBarImp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TControlBarImp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TControlBarImp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TControlBarImp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TControlBarImp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TControlBarImp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_159_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TControlBarImp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_159_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TControlBarImp* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TControlBarImp(*(TControlBarImp*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TControlBarImp G__TTControlBarImp;
static int G__G__Base1_159_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TControlBarImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TControlBarImp*) (soff+(sizeof(TControlBarImp)*i)))->~G__TTControlBarImp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TControlBarImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TControlBarImp*) (soff))->~G__TTControlBarImp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_159_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TControlBarImp* dest = (TControlBarImp*) G__getstructoffset();
   *dest = *(TControlBarImp*) libp->para[0].ref;
   const TControlBarImp& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDatime */
static int G__G__Base1_160_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDatime* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDatime[n];
     } else {
       p = new((void*) gvp) TDatime[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDatime;
     } else {
       p = new((void*) gvp) TDatime;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TDatime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDatime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDatime(*(TDatime*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDatime(*(TDatime*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TDatime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDatime* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDatime((UInt_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TDatime((UInt_t) 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 TDatime((UInt_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TDatime((UInt_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TDatime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDatime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDatime((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDatime((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TDatime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDatime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDatime(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TDatime(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_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__Base1LN_TDatime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDatime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDatime((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TDatime((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__Base1LN_TDatime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime& obj = ((TDatime*) G__getstructoffset())->operator=(*(TDatime*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TDatime*) G__getstructoffset())->AsString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TDatime*) G__getstructoffset())->AsString((char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TDatime*) G__getstructoffset())->AsSQLString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((const TDatime*) G__getstructoffset())->Convert((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((const TDatime*) G__getstructoffset())->Convert());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TDatime*) G__getstructoffset())->Copy(*(TDatime*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TDatime*) G__getstructoffset())->Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetYear());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetMonth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetDay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetDayOfWeek());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetHour());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetMinute());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->GetSecond());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->FillBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TDatime*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TDatime*) G__getstructoffset())->Print();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->ReadBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->Set();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TDatime*) G__getstructoffset())->Set((UInt_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TDatime*) G__getstructoffset())->Set((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->Set((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__Base1_160_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->Set((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDatime*) G__getstructoffset())->Sizeof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDatime::GetDateTime((UInt_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDatime::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDatime::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDatime::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDatime::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDatime*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDatime*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDatime::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDatime::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDatime::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_160_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDatime::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDatime G__TTDatime;
static int G__G__Base1_160_0_45(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[] (TDatime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDatime*) (soff+(sizeof(TDatime)*i)))->~G__TTDatime();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDatime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDatime*) (soff))->~G__TTDatime();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEnv */
static int G__G__Base1_178_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEnv* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEnv((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEnv((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 TEnv[n];
       } else {
         p = new((void*) gvp) TEnv[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEnv;
       } else {
         p = new((void*) gvp) TEnv;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TEnv));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEnv*) G__getstructoffset())->GetTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEnv*) G__getstructoffset())->Defined((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEnv*) G__getstructoffset())->GetRcName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnv*) G__getstructoffset())->SetRcName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEnv*) G__getstructoffset())->GetValue((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TEnv*) G__getstructoffset())->GetValue((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEnv*) G__getstructoffset())->GetValue((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEnv*) G__getstructoffset())->SetValue((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (EEnvLevel) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEnv*) G__getstructoffset())->SetValue((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (EEnvLevel) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEnv*) G__getstructoffset())->SetValue((const char*) 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__Base1_178_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEnv*) G__getstructoffset())->SetValue((const char*) G__int(libp->para[0]), (EEnvLevel) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEnv*) G__getstructoffset())->SetValue((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnv*) G__getstructoffset())->SetValue((const char*) 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__Base1_178_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnv*) G__getstructoffset())->SetValue((const char*) 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__Base1_178_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEnv*) G__getstructoffset())->Lookup((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEnv*) G__getstructoffset())->ReadFile((const char*) G__int(libp->para[0]), (EEnvLevel) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TEnv*) G__getstructoffset())->WriteFile((const char*) G__int(libp->para[0]), (EEnvLevel) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TEnv*) G__getstructoffset())->WriteFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnv*) G__getstructoffset())->Save();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnv*) G__getstructoffset())->SaveLevel((EEnvLevel) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TEnv*) G__getstructoffset())->PrintEnv((EEnvLevel) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TEnv*) G__getstructoffset())->PrintEnv();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEnv*) G__getstructoffset())->IgnoreDuplicates((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEnv::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEnv::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEnv::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEnv::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnv*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEnv::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEnv::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEnv::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_178_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEnv::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEnv G__TTEnv;
static int G__G__Base1_178_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[] (TEnv*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEnv*) (soff+(sizeof(TEnv)*i)))->~G__TTEnv();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEnv*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEnv*) (soff))->~G__TTEnv();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEnvRec */
static int G__G__Base1_183_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEnvRec* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEnvRec[n];
     } else {
       p = new((void*) gvp) TEnvRec[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEnvRec;
     } else {
       p = new((void*) gvp) TEnvRec;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TEnvRec));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEnvRec*) G__getstructoffset())->GetValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEnvRec*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEnvRec*) G__getstructoffset())->GetLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEnvRec::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEnvRec::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEnvRec::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEnvRec::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEnvRec*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEnvRec::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEnvRec::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEnvRec::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_183_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEnvRec::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_183_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEnvRec* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEnvRec(*(TEnvRec*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TEnvRec));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEnvRec G__TTEnvRec;
static int G__G__Base1_183_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEnvRec*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEnvRec*) (soff+(sizeof(TEnvRec)*i)))->~G__TTEnvRec();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEnvRec*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEnvRec*) (soff))->~G__TTEnvRec();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_183_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEnvRec* dest = (TEnvRec*) G__getstructoffset();
   *dest = *(TEnvRec*) libp->para[0].ref;
   const TEnvRec& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TInspectorImp */
static int G__G__Base1_189_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TInspectorImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TInspectorImp[n];
     } else {
       p = new((void*) gvp) TInspectorImp[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TInspectorImp;
     } else {
       p = new((void*) gvp) TInspectorImp;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TInspectorImp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TInspectorImp(
(TObject*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TInspectorImp(
(TObject*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_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__Base1LN_TInspectorImp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInspectorImp*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInspectorImp*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TInspectorImp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TInspectorImp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TInspectorImp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TInspectorImp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TInspectorImp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInspectorImp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInspectorImp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TInspectorImp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TInspectorImp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TInspectorImp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TInspectorImp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_189_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TInspectorImp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_189_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TInspectorImp* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TInspectorImp(*(TInspectorImp*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TInspectorImp G__TTInspectorImp;
static int G__G__Base1_189_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TInspectorImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TInspectorImp*) (soff+(sizeof(TInspectorImp)*i)))->~G__TTInspectorImp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TInspectorImp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TInspectorImp*) (soff))->~G__TTInspectorImp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_189_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TInspectorImp* dest = (TInspectorImp*) G__getstructoffset();
   *dest = *(TInspectorImp*) libp->para[0].ref;
   const TInspectorImp& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGuiFactory */
static int G__G__Base1_190_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGuiFactory* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGuiFactory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGuiFactory((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 TGuiFactory((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGuiFactory((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 TGuiFactory[n];
       } else {
         p = new((void*) gvp) TGuiFactory[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGuiFactory;
       } else {
         p = new((void*) gvp) TGuiFactory;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateApplicationImp((const char*) G__int(libp->para[0]), (int*) G__int(libp->para[1])
, (char**) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateCanvasImp((TCanvas*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateCanvasImp((TCanvas*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateBrowserImp((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateBrowserImp((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateBrowserImp(
(TBrowser*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateBrowserImp((TBrowser*) 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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateContextMenuImp((TContextMenu*) 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__Base1_190_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateControlBarImp((TControlBar*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateControlBarImp((TControlBar*) 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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiFactory*) G__getstructoffset())->CreateInspectorImp((TObject*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGuiFactory::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiFactory::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGuiFactory::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGuiFactory::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiFactory*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiFactory::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGuiFactory::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiFactory::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_190_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGuiFactory::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_190_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGuiFactory* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGuiFactory(*(TGuiFactory*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGuiFactory G__TTGuiFactory;
static int G__G__Base1_190_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGuiFactory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGuiFactory*) (soff+(sizeof(TGuiFactory)*i)))->~G__TTGuiFactory();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGuiFactory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGuiFactory*) (soff))->~G__TTGuiFactory();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_190_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGuiFactory* dest = (TGuiFactory*) G__getstructoffset();
   *dest = *(TGuiFactory*) libp->para[0].ref;
   const TGuiFactory& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFileHandler */
static int G__G__Base1_257_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFileHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFileHandler((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TFileHandler((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TFileHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFileHandler*) G__getstructoffset())->GetFd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileHandler*) G__getstructoffset())->SetFd((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFileHandler*) G__getstructoffset())->ReadNotify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFileHandler*) G__getstructoffset())->WriteNotify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFileHandler*) G__getstructoffset())->HasReadInterest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFileHandler*) G__getstructoffset())->HasWriteInterest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileHandler*) G__getstructoffset())->SetInterest((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileHandler*) G__getstructoffset())->ResetReadyMask();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileHandler*) G__getstructoffset())->SetReadReady();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileHandler*) G__getstructoffset())->SetWriteReady();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TFileHandler*) G__getstructoffset())->IsReadReady());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TFileHandler*) G__getstructoffset())->IsWriteReady());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFileHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFileHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFileHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFileHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFileHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFileHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFileHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFileHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_257_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFileHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFileHandler G__TTFileHandler;
static int G__G__Base1_257_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFileHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFileHandler*) (soff+(sizeof(TFileHandler)*i)))->~G__TTFileHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFileHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFileHandler*) (soff))->~G__TTFileHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStyle */
static int G__G__Base1_284_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStyle* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStyle[n];
     } else {
       p = new((void*) gvp) TStyle[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStyle;
     } else {
       p = new((void*) gvp) TStyle;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TStyle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStyle* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStyle((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TStyle((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__Base1LN_TStyle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStyle* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStyle(*(TStyle*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TStyle(*(TStyle*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TStyle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->AxisChoice((Option_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStyle::BuildStyles();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->cd();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetNdivisions((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetNdivisions());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TStyle*) G__getstructoffset())->GetAttDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetAxisColor((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetAxisColor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetLabelColor((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetLabelColor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetLabelFont((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetLabelFont());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetLabelOffset((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetLabelOffset());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetLabelSize((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetLabelSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleColor((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleColor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleFont((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleFont());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleOffset((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleOffset());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleSize((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTickLength((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTickLength());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetBarOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetBarWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetDrawBorder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetEndErrorSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetErrorX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TStyle*) G__getstructoffset())->GetCanvasPreferGL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetCanvasColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetCanvasBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetCanvasBorderMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetCanvasDefH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetCanvasDefW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetCanvasDefX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetCanvasDefY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetColorPalette((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetColorModelPS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetDateX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetDateY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetFitFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetHatchesLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TStyle*) G__getstructoffset())->GetHatchesSpacing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetLegendBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetNumberOfColors());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetPadColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetPadBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetPadBorderMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetPadBottomMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetPadTopMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetPadLeftMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetPadRightMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TStyle*) G__getstructoffset())->GetPadGridX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TStyle*) G__getstructoffset())->GetPadGridY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetPadTickX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetPadTickY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFuncColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFuncStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFuncWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetGridColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetGridStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetGridWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFrameFillColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFrameLineColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFrameFillStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFrameLineStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFrameLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetFrameBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetFrameBorderMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetHistFillColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetHistLineColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetHistFillStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetHistLineStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetHistLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TStyle*) G__getstructoffset())->GetHistMinimumZero());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TStyle*) G__getstructoffset())->GetHistTopMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetLegoInnerR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetNumberContours());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptFile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptFit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptStat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptTitle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptLogx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptLogy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetOptLogz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetPaintTextFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TStyle*) G__getstructoffset())->GetPaperSize(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetShowEventStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetShowEditor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetShowToolBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetScreenFactor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetStatColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetStatTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetStatBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetStatFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetStatFontSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetStatStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetStatFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetStatX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetStatY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetStatW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetStatH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStyle*) G__getstructoffset())->GetStripDecimals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TStyle*) G__getstructoffset())->GetTimeOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStyle*) G__getstructoffset())->GetTitleAlign());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleFillColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleFontSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TStyle*) G__getstructoffset())->GetTitleBorderSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleXOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleXSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleYOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleYSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetTitleH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetHeaderPS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetTitlePS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetLineStyleString((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((const TStyle*) G__getstructoffset())->GetLineStyleString());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TStyle*) G__getstructoffset())->GetLineScalePS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TStyle*) G__getstructoffset())->IsReading());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->Reset((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->Reset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetColorModelPS((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetColorModelPS();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFitFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFitFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetHeaderPS((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetHatchesLineWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetHatchesSpacing((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetTitlePS((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetLineScalePS((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLineScalePS();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetLineStyleString((Int_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__Base1_284_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetNdivisions((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetNdivisions((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetNdivisions();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetAxisColor((Color_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetAxisColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetAxisColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetLabelColor((Color_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetLabelColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLabelColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetLabelFont((Style_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetLabelFont((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLabelFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLabelOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLabelSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetLegoInnerR((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLegoInnerR();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetScreenFactor((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetScreenFactor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTickLength();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetTitleColor((Color_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetTitleFont((Style_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleFont((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetTitleSize((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetNumberContours((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetNumberContours();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptDate((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptDate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptFile((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptFile();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptFit((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptFit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptLogx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptLogx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptLogy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptLogy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptLogz((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptLogz();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptStat((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptStat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetOptStat((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetOptTitle((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetOptTitle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetBarOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetBarOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetBarWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetBarWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetDateX((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetDateX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetDateY((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetDateY();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetEndErrorSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetEndErrorSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetErrorX((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetErrorX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasPreferGL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasPreferGL();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetDrawBorder((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetDrawBorder();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasBorderMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasBorderMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasDefH((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasDefH();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasDefW((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasDefW();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasDefX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasDefX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetCanvasDefY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetCanvasDefY();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetLegendBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetLegendBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadBorderMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadBorderMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadBottomMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadBottomMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadTopMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadTopMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadLeftMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadLeftMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPadRightMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPadRightMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetPadGridX((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetPadGridY((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetPadTickX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetPadTickY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFuncStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFuncStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFuncColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFuncColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFuncWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFuncWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetGridStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetGridStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetGridColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetGridColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetGridWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetGridWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameFillColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameFillColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameLineColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameFillStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameFillStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameLineStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameLineStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameLineWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameLineWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetFrameBorderMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetFrameBorderMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistFillColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistFillColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistLineColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistFillStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistFillStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistLineStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistLineStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistLineWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistLineWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistMinimumZero((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistMinimumZero();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetHistTopMargin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetHistTopMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetPaintTextFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPaintTextFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetPaperSize((TStyle::EPaperSize) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetPaperSize((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetPaperSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPaperSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatColor((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatTextColor((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatTextColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatFont((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatFontSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatFontSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_213(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatX((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatY((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatY();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatW();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_216(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStatH((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStatH();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetStripDecimals((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetStripDecimals();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_218(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->SetTimeOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_219(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleAlign((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleAlign();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_220(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleFillColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleFillColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_221(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleTextColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleTextColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleFontSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleFontSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleBorderSize((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleBorderSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleXOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleXOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_226(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleXSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleXSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleYOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleYOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_228(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleYSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleYSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_229(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleX((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_230(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleY((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleY();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_231(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleW();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_232(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetTitleH((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetTitleH();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_233(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->ToggleEventStatus();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_234(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->ToggleEditor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_235(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->ToggleToolBar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_236(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyle*) G__getstructoffset())->SetIsReading((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetIsReading();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_237(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SetPalette((Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SetPalette((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyle*) G__getstructoffset())->SetPalette();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_239(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TStyle*) G__getstructoffset())->SaveSource((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TStyle*) G__getstructoffset())->SaveSource((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_240(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStyle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_241(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_242(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStyle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_243(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStyle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_247(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_248(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_249(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStyle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_250(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_284_0_251(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStyle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStyle G__TTStyle;
static int G__G__Base1_284_0_252(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[] (TStyle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStyle*) (soff+(sizeof(TStyle)*i)))->~G__TTStyle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStyle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStyle*) (soff))->~G__TTStyle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_284_0_253(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStyle* dest = (TStyle*) G__getstructoffset();
   *dest = *(TStyle*) libp->para[0].ref;
   const TStyle& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualFFT */
static int G__G__Base1_293_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TVirtualFFT*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualFFT*) G__getstructoffset())->GetNdim());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualFFT*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualFFT*) G__getstructoffset())->GetSign());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualFFT*) G__getstructoffset())->GetTransformFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualFFT*) G__getstructoffset())->Init((Option_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualFFT*) G__getstructoffset())->IsInplace());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TVirtualFFT*) G__getstructoffset())->GetPoints((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TVirtualFFT*) G__getstructoffset())->GetPoints((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TVirtualFFT*) G__getstructoffset())->GetPointReal((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TVirtualFFT*) G__getstructoffset())->GetPointReal((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TVirtualFFT*) G__getstructoffset())->GetPointReal((const Int_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TVirtualFFT*) G__getstructoffset())->GetPointReal((const Int_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointComplex((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointComplex((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointComplex((const Int_t*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointComplex((const Int_t*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 68, (long) ((const TVirtualFFT*) G__getstructoffset())->GetPointsReal((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 68, (long) ((const TVirtualFFT*) G__getstructoffset())->GetPointsReal());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointsComplex((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointsComplex((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointsComplex((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TVirtualFFT*) G__getstructoffset())->GetPointsComplex((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualFFT*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualFFT*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualFFT*) G__getstructoffset())->SetPoint((const Int_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualFFT*) G__getstructoffset())->SetPoint((const Int_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualFFT*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualFFT*) G__getstructoffset())->SetPointComplex((Int_t) G__int(libp->para[0]), *(TComplex*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualFFT*) G__getstructoffset())->SetPointsComplex((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualFFT*) G__getstructoffset())->Transform();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualFFT::FFT((Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualFFT::SineCosine((Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualFFT::GetCurrentTransform());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualFFT::SetTransform((TVirtualFFT*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualFFT::GetDefaultFFT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TVirtualFFT::SetDefaultFFT((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TVirtualFFT::SetDefaultFFT();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualFFT::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualFFT::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualFFT::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualFFT::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualFFT*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualFFT::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualFFT::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualFFT::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_293_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualFFT::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualFFT G__TTVirtualFFT;
static int G__G__Base1_293_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualFFT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualFFT*) (soff+(sizeof(TVirtualFFT)*i)))->~G__TTVirtualFFT();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualFFT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualFFT*) (soff))->~G__TTVirtualFFT();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_293_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualFFT* dest = (TVirtualFFT*) G__getstructoffset();
   *dest = *(TVirtualFFT*) libp->para[0].ref;
   const TVirtualFFT& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualViewer3D */
static int G__G__Base1_311_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualViewer3D*) G__getstructoffset())->PreferLocalFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualViewer3D*) G__getstructoffset())->CanLoopOnPrimitives());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->PadPaint((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualViewer3D*) G__getstructoffset())->ObjectPaint((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualViewer3D*) G__getstructoffset())->ObjectPaint((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->BeginScene();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualViewer3D*) G__getstructoffset())->BuildingScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->EndScene();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TVirtualViewer3D*) G__getstructoffset())->AddObject(*(TBuffer3D*) libp->para[0].ref, (Bool_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TVirtualViewer3D*) G__getstructoffset())->AddObject(*(TBuffer3D*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TVirtualViewer3D*) G__getstructoffset())->AddObject((UInt_t) G__int(libp->para[0]), *(TBuffer3D*) libp->para[1].ref
, (Bool_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TVirtualViewer3D*) G__getstructoffset())->AddObject((UInt_t) G__int(libp->para[0]), *(TBuffer3D*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TVirtualViewer3D*) G__getstructoffset())->OpenComposite(*(TBuffer3D*) libp->para[0].ref, (Bool_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TVirtualViewer3D*) G__getstructoffset())->OpenComposite(*(TBuffer3D*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->CloseComposite();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->AddCompositeOp((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualViewer3D*) G__getstructoffset())->SelectObject((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->DrawViewer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->PrintObjects();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->ResetCameras();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->ResetCamerasAfterNextUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TVirtualViewer3D::Viewer3D((TVirtualPad*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TVirtualViewer3D::Viewer3D((TVirtualPad*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TVirtualViewer3D::Viewer3D());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualViewer3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualViewer3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualViewer3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualViewer3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualViewer3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualViewer3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualViewer3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualViewer3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_311_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualViewer3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualViewer3D G__TTVirtualViewer3D;
static int G__G__Base1_311_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[] (TVirtualViewer3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualViewer3D*) (soff+(sizeof(TVirtualViewer3D)*i)))->~G__TTVirtualViewer3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualViewer3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualViewer3D*) (soff))->~G__TTVirtualViewer3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_311_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualViewer3D* dest = (TVirtualViewer3D*) G__getstructoffset();
   *dest = *(TVirtualViewer3D*) libp->para[0].ref;
   const TVirtualViewer3D& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualGLPainter */
static int G__G__Base1_318_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLPainter*) G__getstructoffset())->Paint();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLPainter*) G__getstructoffset())->Pan((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__Base1_318_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualGLPainter*) G__getstructoffset())->PlotSelected((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TVirtualGLPainter*) G__getstructoffset())->GetPlotInfo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGLPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGLPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualGLPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGLPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualGLPainter*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLPainter*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLPainter*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGLPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGLPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGLPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_318_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGLPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualGLPainter G__TTVirtualGLPainter;
static int G__G__Base1_318_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[] (TVirtualGLPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualGLPainter*) (soff+(sizeof(TVirtualGLPainter)*i)))->~G__TTVirtualGLPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualGLPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualGLPainter*) (soff))->~G__TTVirtualGLPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_318_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualGLPainter* dest = (TVirtualGLPainter*) G__getstructoffset();
   *dest = *(TVirtualGLPainter*) libp->para[0].ref;
   const TVirtualGLPainter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualGLManip */
static int G__G__Base1_319_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualGLManip*) G__getstructoffset())->Select(*(TGLCamera*) libp->para[0].ref, *(TGLRect*) libp->para[1].ref
, *(TGLBoundingBox*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGLManip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGLManip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualGLManip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGLManip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualGLManip*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLManip*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLManip*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGLManip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGLManip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGLManip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGLManip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_319_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGLManip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualGLManip G__TTVirtualGLManip;
static int G__G__Base1_319_0_14(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[] (TVirtualGLManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualGLManip*) (soff+(sizeof(TVirtualGLManip)*i)))->~G__TTVirtualGLManip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualGLManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualGLManip*) (soff))->~G__TTVirtualGLManip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_319_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualGLManip* dest = (TVirtualGLManip*) G__getstructoffset();
   *dest = *(TVirtualGLManip*) libp->para[0].ref;
   const TVirtualGLManip& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLManager */
static int G__G__Base1_320_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLManager*) G__getstructoffset())->InitGLWindow((Window_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLManager*) G__getstructoffset())->CreateGLContext((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManager*) G__getstructoffset())->AttachOffScreenDevice((Int_t) G__int(libp->para[0]), (Int_t) 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__Base1_320_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManager*) G__getstructoffset())->ResizeOffScreenDevice((Int_t) G__int(libp->para[0]), (Int_t) 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__Base1_320_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->SelectOffScreenDevice((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLManager*) G__getstructoffset())->GetVirtualXInd((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->MarkForDirectCopy((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->ExtractViewport((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__Base1_320_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->ReadGLBuffer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManager*) G__getstructoffset())->MakeCurrent((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->Flush((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->DeleteGLContext((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManager*) G__getstructoffset())->SelectManip((TVirtualGLManip*) G__int(libp->para[0]), (TGLCamera*) G__int(libp->para[1])
, (TGLRect*) G__int(libp->para[2]), (TGLBoundingBox*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->PaintSingleObject((TVirtualGLPainter*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->PanObject((TVirtualGLPainter*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->PrintViewer((TVirtualViewer3D*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManager*) G__getstructoffset())->PlotSelected((TVirtualGLPainter*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGLManager*) G__getstructoffset())->GetPlotInfo((TVirtualGLPainter*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManager*) G__getstructoffset())->HighColorFormat((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TGLManager*& obj = TGLManager::Instance();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_320_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLManager G__TTGLManager;
static int G__G__Base1_320_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[] (TGLManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLManager*) (soff+(sizeof(TGLManager)*i)))->~G__TTGLManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLManager*) (soff))->~G__TTGLManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPaintDevice */
static int G__G__Base1_323_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLPaintDevice*) G__getstructoffset())->MakeCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPaintDevice*) G__getstructoffset())->SwapBuffers();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPaintDevice*) G__getstructoffset())->GetPixelFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPaintDevice*) G__getstructoffset())->GetContext());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPaintDevice*) G__getstructoffset())->ExtractViewport((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPaintDevice::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPaintDevice::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPaintDevice::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPaintDevice::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPaintDevice*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPaintDevice*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPaintDevice*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPaintDevice*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPaintDevice::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPaintDevice::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPaintDevice::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_323_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPaintDevice::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPaintDevice G__TTGLPaintDevice;
static int G__G__Base1_323_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPaintDevice*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPaintDevice*) (soff+(sizeof(TGLPaintDevice)*i)))->~G__TTGLPaintDevice();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPaintDevice*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPaintDevice*) (soff))->~G__TTGLPaintDevice();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_323_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPaintDevice* dest = (TGLPaintDevice*) G__getstructoffset();
   *dest = *(TGLPaintDevice*) libp->para[0].ref;
   const TGLPaintDevice& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualPadEditor */
static int G__G__Base1_324_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPadEditor*) G__getstructoffset())->IsGlobal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->DrawLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->DrawLineNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->DrawText((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->DrawTextNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->FillAttributes((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__Base1_324_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->LineAttributes((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->MarkerAttributes((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->TextAttributes((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->Build();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->DeleteEditors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->SetGlobal((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPadEditor*) G__getstructoffset())->GetCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadEditor::GetEditorName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) TVirtualPadEditor::GetPadEditor((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TVirtualPadEditor::GetPadEditor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualPadEditor::LoadEditor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::HideEditor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::ShowEditor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::SetPadEditorName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::Terminate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::UpdateFillAttributes((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__Base1_324_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::UpdateLineAttributes((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::UpdateMarkerAttributes((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::UpdateTextAttributes((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualPadEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualPadEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPadEditor*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPadEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_324_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPadEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualPadEditor G__TTVirtualPadEditor;
static int G__G__Base1_324_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualPadEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualPadEditor*) (soff+(sizeof(TVirtualPadEditor)*i)))->~G__TTVirtualPadEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualPadEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualPadEditor*) (soff))->~G__TTVirtualPadEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_324_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualPadEditor* dest = (TVirtualPadEditor*) G__getstructoffset();
   *dest = *(TVirtualPadEditor*) libp->para[0].ref;
   const TVirtualPadEditor& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualX */
static int G__G__Base1_327_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualX* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVirtualX[n];
     } else {
       p = new((void*) gvp) TVirtualX[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVirtualX;
     } else {
       p = new((void*) gvp) TVirtualX;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TVirtualX));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualX* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVirtualX((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVirtualX((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__Base1LN_TVirtualX));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->Init((void*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->Init());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ClearWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ClosePixmap();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->CloseWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->CopyPixmap((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualX*) G__getstructoffset())->CreateOpenGLContext((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualX*) G__getstructoffset())->CreateOpenGLContext();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualX*) G__getstructoffset())->DeleteOpenGLContext((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualX*) G__getstructoffset())->DeleteOpenGLContext();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawBox((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TVirtualX::EBoxMode) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawCellArray(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawFillArea((Int_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawLine((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawPolyLine((Int_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (TVirtualX::ETextMode) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TVirtualX*) G__getstructoffset())->ExecCommand((TGWin32Command*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetCharacterUp(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->GetDrawMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->GetDoubleBuffer((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetGeometry((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(UInt_t*) G__UIntref(&libp->para[3])
, *(UInt_t*) G__UIntref(&libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((TVirtualX*) G__getstructoffset())->DisplayName((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((TVirtualX*) G__getstructoffset())->DisplayName());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetNativeEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->GetPixel((Color_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetPlanes(*(Int_t*) G__Intref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetRGB((Int_t) G__int(libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetTextExtent(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, (char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualX*) G__getstructoffset())->GetFontAscent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualX*) G__getstructoffset())->GetFontDescent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TVirtualX*) G__getstructoffset())->GetTextMagnitude());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->GetWindowID((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualX*) G__getstructoffset())->HasTTFonts());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->InitWindow((ULong_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->AddWindow((ULong_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->AddPixmap((ULong_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->RemoveWindow((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->MoveWindow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->OpenPixmap((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->QueryPointer(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->ReadGIF((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Window_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->ReadGIF((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->RequestLocator((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->RequestString((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->RescaleWindow((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->ResizePixmap((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ResizeWindow((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SelectWindow((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SelectPixmap((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetCharacterUp((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetClipOFF((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetClipRegion((Int_t) G__int(libp->para[0]), (Int_t) 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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetCursor((Int_t) G__int(libp->para[0]), (ECursor) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetDoubleBuffer((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__Base1_327_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetDoubleBufferOFF();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetDoubleBufferON();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetDrawMode((TVirtualX::EDrawMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetLineType((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__Base1_327_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetOpacity((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetRGB((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->SetTextFont((char*) G__int(libp->para[0]), (TVirtualX::ETextSetMode) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetTextMagnitude((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->UpdateWindow((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualX*) G__getstructoffset())->Warp((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Window_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualX*) G__getstructoffset())->Warp((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->WriteGIF((char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->WritePixmap((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (char*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetCurrentWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualX*) G__getstructoffset())->SupportsExtension((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetWindowAttributes((Window_t) G__int(libp->para[0]), *(WindowAttributes_t*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->MapWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->MapSubwindows((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->MapRaised((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->UnmapWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DestroyWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DestroySubwindows((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->RaiseWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->LowerWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->MoveWindow((Window_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->MoveResizeWindow((Window_t) G__int(libp->para[0]), (Int_t) 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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ResizeWindow((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->IconifyWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->NeedRedraw((ULong_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ReparentWindow((Window_t) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWindowBackground((Window_t) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWindowBackgroundPixmap((Window_t) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreateWindow(
(Window_t) G__int(libp->para[0]), (Int_t) 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]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]), (SetWindowAttributes_t*) G__int(libp->para[9])
, (UInt_t) G__int(libp->para[10])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->OpenDisplay((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->CloseDisplay();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetDisplay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetVisual());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualX*) G__getstructoffset())->GetScreen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualX*) G__getstructoffset())->GetDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TVirtualX*) G__getstructoffset())->ScreenWidthMM());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetColormap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->InternAtom((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetDefaultRootWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TVirtualX*) G__getstructoffset())->GetParent((Window_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->LoadQueryFont((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->GetFontHandle((FontStruct_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DeleteFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreateGC((Drawable_t) G__int(libp->para[0]), (GCValues_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ChangeGC((GContext_t) G__int(libp->para[0]), (GCValues_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->CopyGC((GContext_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Mask_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DeleteGC((GContext_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreateCursor((ECursor) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetCursor((Window_t) G__int(libp->para[0]), (Cursor_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreatePixmap((Drawable_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreatePixmap(
(Drawable_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (ULong_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreateBitmap((Drawable_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DeletePixmap((Pixmap_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->CreatePictureFromFile((Drawable_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(Pixmap_t*) G__ULongref(&libp->para[2]), *(Pixmap_t*) G__ULongref(&libp->para[3])
, *(PictureAttributes_t*) libp->para[4].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->CreatePictureFromData((Drawable_t) G__int(libp->para[0]), (char**) G__int(libp->para[1])
, *(Pixmap_t*) G__ULongref(&libp->para[2]), *(Pixmap_t*) G__ULongref(&libp->para[3])
, *(PictureAttributes_t*) libp->para[4].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreatePixmapFromData((unsigned char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->ReadPictureDataFromFile((const char*) G__int(libp->para[0]), (char***) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DeletePictureData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetDashes((GContext_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->ParseColor((Colormap_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(ColorStruct_t*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->AllocColor((Colormap_t) G__int(libp->para[0]), *(ColorStruct_t*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->QueryColor((Colormap_t) G__int(libp->para[0]), *(ColorStruct_t*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->FreeColor((Colormap_t) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->EventsPending());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->NextEvent(*(Event_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->Bell((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->CopyArea(
(Drawable_t) G__int(libp->para[0]), (Drawable_t) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ChangeWindowAttributes((Window_t) G__int(libp->para[0]), (SetWindowAttributes_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ChangeProperty((Window_t) G__int(libp->para[0]), (Atom_t) G__int(libp->para[1])
, (Atom_t) G__int(libp->para[2]), (UChar_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__Base1_327_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawLine((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ClearArea((Window_t) G__int(libp->para[0]), (Int_t) 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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->CheckEvent((Window_t) G__int(libp->para[0]), (EGEventType) G__int(libp->para[1])
, *(Event_t*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SendEvent((Window_t) G__int(libp->para[0]), (Event_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->WMDeleteNotify((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualX*) G__getstructoffset())->SetKeyAutoRepeat((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualX*) G__getstructoffset())->SetKeyAutoRepeat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualX*) G__getstructoffset())->GrabKey((Window_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualX*) G__getstructoffset())->GrabKey((Window_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TVirtualX*) G__getstructoffset())->GrabButton(
(Window_t) G__int(libp->para[0]), (EMouseButton) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Window_t) G__int(libp->para[4]), (Cursor_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TVirtualX*) G__getstructoffset())->GrabButton((Window_t) G__int(libp->para[0]), (EMouseButton) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Window_t) G__int(libp->para[4]), (Cursor_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TVirtualX*) G__getstructoffset())->GrabPointer((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Window_t) G__int(libp->para[2]), (Cursor_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TVirtualX*) G__getstructoffset())->GrabPointer((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Window_t) G__int(libp->para[2]), (Cursor_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TVirtualX*) G__getstructoffset())->GrabPointer((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Window_t) G__int(libp->para[2]), (Cursor_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWindowName((Window_t) G__int(libp->para[0]), (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetIconName((Window_t) G__int(libp->para[0]), (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetIconPixmap((Window_t) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetClassHints((Window_t) G__int(libp->para[0]), (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__Base1_327_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetMWMHints((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWMPosition((Window_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWMSize((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWMSizeHints(
(Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWMState((Window_t) G__int(libp->para[0]), (EInitialState) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetWMTransientHint((Window_t) G__int(libp->para[0]), (Window_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawString((Drawable_t) G__int(libp->para[0]), (GContext_t) 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]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->TextWidth((FontStruct_t) 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__Base1_327_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetFontProperties((FontStruct_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetGCValues((GContext_t) G__int(libp->para[0]), *(GCValues_t*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->GetFontStruct((FontH_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->FreeFontStruct((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ClearWindow((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->KeysymToKeycode((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->FillRectangle((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawRectangle((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DrawSegments((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Segment_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SelectInput((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->GetInputFocus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetInputFocus((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->GetPrimarySelectionOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetPrimarySelectionOwner((Window_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ConvertPrimarySelection((Window_t) G__int(libp->para[0]), (Atom_t) G__int(libp->para[1])
, (Time_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->LookupString((Event_t*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(UInt_t*) G__UIntref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetPasteBuffer((Window_t) G__int(libp->para[0]), (Atom_t) G__int(libp->para[1])
, *(TString*) libp->para[2].ref, *(Int_t*) G__Intref(&libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->TranslateCoordinates(
(Window_t) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Window_t*) G__ULongref(&libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetWindowSize((Drawable_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(UInt_t*) G__UIntref(&libp->para[3])
, *(UInt_t*) G__UIntref(&libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->FillPolygon((Window_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Point_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->QueryPointer(
(Window_t) G__int(libp->para[0]), *(Window_t*) G__ULongref(&libp->para[1])
, *(Window_t*) G__ULongref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6]), *(UInt_t*) G__UIntref(&libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetForeground((GContext_t) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetClipRectangles((GContext_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Rectangle_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__Base1_327_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualX*) G__getstructoffset())->Update((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualX*) G__getstructoffset())->Update();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreateRegion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DestroyRegion((Region_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->UnionRectWithRegion((Rectangle_t*) G__int(libp->para[0]), (Region_t) G__int(libp->para[1])
, (Region_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->PolygonRegion((Point_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->UnionRegion((Region_t) G__int(libp->para[0]), (Region_t) G__int(libp->para[1])
, (Region_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->IntersectRegion((Region_t) G__int(libp->para[0]), (Region_t) G__int(libp->para[1])
, (Region_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SubtractRegion((Region_t) G__int(libp->para[0]), (Region_t) G__int(libp->para[1])
, (Region_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->XorRegion((Region_t) G__int(libp->para[0]), (Region_t) G__int(libp->para[1])
, (Region_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->EmptyRegion((Region_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->PointInRegion((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Region_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->EqualRegion((Region_t) G__int(libp->para[0]), (Region_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetRegionBox((Region_t) G__int(libp->para[0]), (Rectangle_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TVirtualX*) G__getstructoffset())->ListFonts((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->FreeFontNames((char**) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->CreateImage((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->GetImageSize((Drawable_t) G__int(libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->PutPixel((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (ULong_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->PutImage(
(Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Drawable_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DeleteImage((Drawable_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 66, (long) ((TVirtualX*) G__getstructoffset())->GetColorBits((Drawable_t) G__int(libp->para[0]), (Int_t) 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])));
      break;
   case 4:
      G__letint(result7, 66, (long) ((TVirtualX*) G__getstructoffset())->GetColorBits((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 66, (long) ((TVirtualX*) G__getstructoffset())->GetColorBits((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 66, (long) ((TVirtualX*) G__getstructoffset())->GetColorBits((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 66, (long) ((TVirtualX*) G__getstructoffset())->GetColorBits((Drawable_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ShapeCombineMask((Window_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Pixmap_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->DeleteProperty((Window_t) G__int(libp->para[0]), *(Atom_t*) G__ULongref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualX*) G__getstructoffset())->GetProperty(
(Window_t) G__int(libp->para[0]), (Atom_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (Long_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]), (Atom_t) G__int(libp->para[5])
, (Atom_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])
, (ULong_t*) G__int(libp->para[8]), (ULong_t*) G__int(libp->para[9])
, (unsigned char**) G__int(libp->para[10])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ChangeActivePointerGrab((Window_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Cursor_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ConvertSelection((Window_t) G__int(libp->para[0]), *(Atom_t*) G__ULongref(&libp->para[1])
, *(Atom_t*) G__ULongref(&libp->para[2]), *(Atom_t*) G__ULongref(&libp->para[3])
, *(Time_t*) G__ULongref(&libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->SetSelectionOwner((Window_t) G__int(libp->para[0]), *(Atom_t*) G__ULongref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->ChangeProperties((Window_t) G__int(libp->para[0]), (Atom_t) G__int(libp->para[1])
, (Atom_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (UChar_t*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetDNDAware((Window_t) G__int(libp->para[0]), (Atom_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->SetTypeList((Window_t) G__int(libp->para[0]), (Atom_t) G__int(libp->para[1])
, (Atom_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualX*) G__getstructoffset())->FindRWindow((Window_t) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (Window_t) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualX*) G__getstructoffset())->IsDNDAware((Window_t) G__int(libp->para[0]), (Atom_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_213(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualX*) G__getstructoffset())->IsCmdThread());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVirtualX*& obj = TVirtualX::Instance();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualX::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_216(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualX::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualX::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_218(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualX::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualX*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualX::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualX::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualX::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_327_0_226(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualX::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base1_327_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TVirtualX* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TVirtualX(*(TVirtualX*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base1LN_TVirtualX));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualX G__TTVirtualX;
static int G__G__Base1_327_0_228(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[] (TVirtualX*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualX*) (soff+(sizeof(TVirtualX)*i)))->~G__TTVirtualX();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualX*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualX*) (soff))->~G__TTVirtualX();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_327_0_229(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualX* dest = (TVirtualX*) G__getstructoffset();
   *dest = *(TVirtualX*) libp->para[0].ref;
   const TVirtualX& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualPadPainter */
static int G__G__Base1_339_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetLineColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetLineStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetLineStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetLineWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetFillColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetFillStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualPadPainter*) G__getstructoffset())->IsTransparent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetFillColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetFillStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetOpacity((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetTextAlign());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVirtualPadPainter*) G__getstructoffset())->GetTextAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TVirtualPadPainter*) G__getstructoffset())->GetTextFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVirtualPadPainter*) G__getstructoffset())->GetTextSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVirtualPadPainter*) G__getstructoffset())->GetTextMagnitude());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextAlign((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextAlign();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextAngle((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextAngle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextFont((Font_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SetTextSizePixels((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualPadPainter*) G__getstructoffset())->CreateDrawable((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->ClearDrawable();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->CopyDrawable((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DestroyDrawable();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->SelectDrawable((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->InitPainter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->InvalidateCS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->LockPainter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawLineNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TVirtualPadPainter::EBoxMode) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawFillArea((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawFillArea((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawPolyLine((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawPolyLineNDC((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawText((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]), (TVirtualPadPainter::ETextMode) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->DrawTextNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]), (TVirtualPadPainter::ETextMode) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TVirtualPadPainter*) G__getstructoffset())->SaveImage((TVirtualPad*) G__int(libp->para[0]), (const char*) 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__Base1_339_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) TVirtualPadPainter::PadPainter((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TVirtualPadPainter::PadPainter());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualPadPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualPadPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPadPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualPadPainter*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPadPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPadPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPadPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_339_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPadPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualPadPainter G__TTVirtualPadPainter;
static int G__G__Base1_339_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualPadPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualPadPainter*) (soff+(sizeof(TVirtualPadPainter)*i)))->~G__TTVirtualPadPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualPadPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualPadPainter*) (soff))->~G__TTVirtualPadPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base1_339_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualPadPainter* dest = (TVirtualPadPainter*) G__getstructoffset();
   *dest = *(TVirtualPadPainter*) libp->para[0].ref;
   const TVirtualPadPainter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualPS */
static int G__G__Base1_342_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->CellArrayBegin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->CellArrayFill((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->CellArrayEnd();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPS*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPS*) G__getstructoffset())->Close();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->DrawBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->DrawFrame(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->DrawPS((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->DrawPS((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->NewPage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPS*) G__getstructoffset())->Open((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPS*) G__getstructoffset())->Open((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->Text((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->SetColor((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPS*) G__getstructoffset())->PrintFast((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPS*) G__getstructoffset())->PrintFast((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPS*) G__getstructoffset())->PrintStr((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPS*) G__getstructoffset())->PrintStr();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualPS*) G__getstructoffset())->WriteInteger((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualPS*) G__getstructoffset())->WriteInteger((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->WriteReal((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TVirtualPS*) G__getstructoffset())->GetStream());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->SetStream((ofstream*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualPS*) G__getstructoffset())->SetType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualPS*) G__getstructoffset())->SetType();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualPS*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualPS::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPS::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualPS::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualPS::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPS*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPS::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPS::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualPS::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1_342_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualPS::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualPS G__TTVirtualPS;
static int G__G__Base1_342_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualPS*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualPS*) (soff+(sizeof(TVirtualPS)*i)))->~G__TTVirtualPS();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualPS*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualPS*) (soff))->~G__TTVirtualPS();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Base1__0_282(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
         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__Base1__0_283(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+(*(TString*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         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__Base1__0_284(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
         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__Base1__0_285(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+(*(TString*) libp->para[0].ref, (char) G__int(libp->para[1]));
         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__Base1__0_286(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+(*(TString*) libp->para[0].ref, (Long_t) G__int(libp->para[1]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_287(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+(*(TString*) libp->para[0].ref, (ULong_t) G__int(libp->para[1]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_290(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+((char) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
         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__Base1__0_291(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+((Long_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
         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__Base1__0_292(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = operator+((ULong_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
         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__Base1__0_295(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_296(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TString*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_301(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(TString*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_302(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_304(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ToLower(*(TString*) libp->para[0].ref);
         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__Base1__0_305(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ToUpper(*(TString*) libp->para[0].ref);
         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__Base1__0_306(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) Hash(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_307(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) Hash((TString*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_308(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) Hash((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_309(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      G__letint(result7, 67, (long) Form((const char*) G__int(libp->para[0]), G__va_arg_bufobj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_310(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      Printf((const char*) G__int(libp->para[0]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_311(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 67, (long) Strip((const char*) G__int(libp->para[0]), (char) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 67, (long) Strip((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_312(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) StrDup((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_313(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) Compress((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_314(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) EscChar((const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (char*) G__int(libp->para[3])
, (char) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_315(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) UnEscChar((const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (char*) G__int(libp->para[3])
, (char) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_316(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_326(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_327(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_344(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TDatime*) libp->para[0].ref, *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_345(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(TDatime*) libp->para[0].ref, *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_346(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(TDatime*) libp->para[0].ref, *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_347(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(TDatime*) libp->para[0].ref, *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_348(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(TDatime*) libp->para[0].ref, *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_349(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(TDatime*) libp->para[0].ref, *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_358(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      Info((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_359(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      Warning((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_360(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      Error((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_362(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      SysError((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base1__0_363(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      Fatal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TBuffer */

/* TDirectory */

/* TRootIOCtor */

/* ROOT */

/* TBrowser */

/* TApplicationImp */

/* TApplication */

/* TAtt3D */

/* TAttAxis */

/* TAttBBox */

/* TAttFill */

/* TAttLine */

/* TAttMarker */

/* TAttPad */

/* TAttText */

/* TBenchmark */

/* TBrowserImp */

/* TContextMenu */

/* TBuffer3D */

/* TCanvasImp */

/* TColor */

/* TContextMenuImp */

/* TVirtualPad */

/* TControlBarImp */

/* TDatime */

/* TEnv */

/* TEnvRec */

/* TInspectorImp */

/* TGuiFactory */

/* TFileHandler */

/* TStyle */

/* TVirtualFFT */

/* TVirtualViewer3D */

/* TVirtualGLPainter */

/* TVirtualGLManip */

/* TGLManager */

/* TGLPaintDevice */

/* TVirtualPadEditor */

/* TVirtualX */

/* TVirtualPadPainter */

/* TVirtualPS */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Base1 {
 public:
  G__Sizep2memfuncG__Base1(): p(&G__Sizep2memfuncG__Base1::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Base1::*p)();
};

size_t G__get_sizep2memfuncG__Base1()
{
  G__Sizep2memfuncG__Base1 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__Base1() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TBuffer))) {
     TBuffer *G__Lderived;
     G__Lderived=(TBuffer*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TBuffer),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TDirectory))) {
     TDirectory *G__Lderived;
     G__Lderived=(TDirectory*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TDirectory),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TDirectory),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TNamed))) {
     TNamed *G__Lderived;
     G__Lderived=(TNamed*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TNamed),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TBrowser))) {
     TBrowser *G__Lderived;
     G__Lderived=(TBrowser*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TBrowser),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TBrowser),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TApplication))) {
     TApplication *G__Lderived;
     G__Lderived=(TApplication*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TApplication),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TApplication),G__get_linked_tagnum(&G__G__Base1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TBenchmark))) {
     TBenchmark *G__Lderived;
     G__Lderived=(TBenchmark*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TBenchmark),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TBenchmark),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TContextMenu))) {
     TContextMenu *G__Lderived;
     G__Lderived=(TContextMenu*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TContextMenu),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TContextMenu),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D))) {
     TBuffer3D *G__Lderived;
     G__Lderived=(TBuffer3D*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TColor))) {
     TColor *G__Lderived;
     G__Lderived=(TColor*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TColor),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TColor),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad))) {
     TVirtualPad *G__Lderived;
     G__Lderived=(TVirtualPad*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),G__get_linked_tagnum(&G__G__Base1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),G__get_linked_tagnum(&G__G__Base1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttPad *G__Lpbase=(TAttPad*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),G__get_linked_tagnum(&G__G__Base1LN_TAttPad),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),G__get_linked_tagnum(&G__G__Base1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TEnv))) {
     TEnv *G__Lderived;
     G__Lderived=(TEnv*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TEnv),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TEnvRec))) {
     TEnvRec *G__Lderived;
     G__Lderived=(TEnvRec*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TEnvRec),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory))) {
     TGuiFactory *G__Lderived;
     G__Lderived=(TGuiFactory*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TFileHandler))) {
     TFileHandler *G__Lderived;
     G__Lderived=(TFileHandler*)0x1000;
     {
       TSysEvtHandler *G__Lpbase=(TSysEvtHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TFileHandler),G__get_linked_tagnum(&G__G__Base1LN_TSysEvtHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TFileHandler),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TFileHandler),G__get_linked_tagnum(&G__G__Base1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TStyle))) {
     TStyle *G__Lderived;
     G__Lderived=(TStyle*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle),G__get_linked_tagnum(&G__G__Base1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle),G__get_linked_tagnum(&G__G__Base1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle),G__get_linked_tagnum(&G__G__Base1LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle),G__get_linked_tagnum(&G__G__Base1LN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT))) {
     TVirtualFFT *G__Lderived;
     G__Lderived=(TVirtualFFT*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D))) {
     TVirtualViewer3D *G__Lderived;
     G__Lderived=(TVirtualViewer3D*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TGLManager))) {
     TGLManager *G__Lderived;
     G__Lderived=(TGLManager*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TGLManager),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TGLManager),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX))) {
     TVirtualX *G__Lderived;
     G__Lderived=(TVirtualX*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX),G__get_linked_tagnum(&G__G__Base1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX),G__get_linked_tagnum(&G__G__Base1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX),G__get_linked_tagnum(&G__G__Base1LN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX),G__get_linked_tagnum(&G__G__Base1LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS))) {
     TVirtualPS *G__Lderived;
     G__Lderived=(TVirtualPS*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),G__get_linked_tagnum(&G__G__Base1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),G__get_linked_tagnum(&G__G__Base1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),G__get_linked_tagnum(&G__G__Base1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),G__get_linked_tagnum(&G__G__Base1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),G__get_linked_tagnum(&G__G__Base1LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),G__get_linked_tagnum(&G__G__Base1LN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Base1() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   G__search_typename2("UShort_t",114,-1,0,-1);
   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Float16_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes written with a truncated mantissa",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Double32_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes in memory, written as a 4 bytes float",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("Font_t",115,-1,0,-1);
   G__setnewtype(-1,"Font number (short)",0);
   G__search_typename2("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Width_t",115,-1,0,-1);
   G__setnewtype(-1,"Line width (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("Size_t",102,-1,0,-1);
   G__setnewtype(-1,"Attribute size (float)",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("NewFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__Base1LN_ROOT));
   G__setnewtype(-1,"void *(*NewFunc_t)(void *);",0);
   G__search_typename2("NewArrFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__Base1LN_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__Base1LN_ROOT));
   G__setnewtype(-1,"void  (*DelFunc_t)(void *);",0);
   G__search_typename2("DelArrFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__Base1LN_ROOT));
   G__setnewtype(-1,"void  (*DelArrFunc_t)(void *);",0);
   G__search_typename2("DesFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__Base1LN_ROOT));
   G__setnewtype(-1,"void  (*DesFunc_t)(void *);",0);
   G__search_typename2("DirAutoAdd_t",89,-1,0,G__get_linked_tagnum(&G__G__Base1LN_ROOT));
   G__setnewtype(-1,"void  (*DirAutoAdd_t)(void *, TDirectory*);",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Base1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ReAllocCharFun_t",89,-1,0,-1);
   G__setnewtype(-1,"char *(*ReAllocCharFun_t)(char*, size_t, size_t);",0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CacheList_t",117,G__get_linked_tagnum(&G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,G__get_linked_tagnum(&G__G__Base1LN_TBuffer));
   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__Base1LN_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__Base1LN_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__Base1LN_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__Base1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__Base1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__Base1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__Base1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__Base1LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Handle_t",107,-1,0,-1);
   G__setnewtype(-1,"Generic resource handle",0);
   G__search_typename2("Display_t",107,-1,0,-1);
   G__setnewtype(-1,"Display handle",0);
   G__search_typename2("Visual_t",107,-1,0,-1);
   G__setnewtype(-1,"Visual handle",0);
   G__search_typename2("Window_t",107,-1,0,-1);
   G__setnewtype(-1,"Window handle",0);
   G__search_typename2("Pixmap_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixmap handle",0);
   G__search_typename2("Drawable_t",107,-1,0,-1);
   G__setnewtype(-1,"Drawable handle",0);
   G__search_typename2("Region_t",107,-1,0,-1);
   G__setnewtype(-1,"Region handle",0);
   G__search_typename2("Colormap_t",107,-1,0,-1);
   G__setnewtype(-1,"Colormap handle",0);
   G__search_typename2("Cursor_t",107,-1,0,-1);
   G__setnewtype(-1,"Cursor handle",0);
   G__search_typename2("FontH_t",107,-1,0,-1);
   G__setnewtype(-1,"Font handle (as opposed to Font_t which is an index)",0);
   G__search_typename2("Atom_t",107,-1,0,-1);
   G__setnewtype(-1,"WM token",0);
   G__search_typename2("GContext_t",107,-1,0,-1);
   G__setnewtype(-1,"Graphics context handle",0);
   G__search_typename2("FontStruct_t",107,-1,0,-1);
   G__setnewtype(-1,"Pointer to font structure",0);
   G__search_typename2("Mask_t",104,-1,0,-1);
   G__setnewtype(-1,"Structure mask type",0);
   G__search_typename2("Time_t",107,-1,0,-1);
   G__setnewtype(-1,"Event time",0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TBuffer */
static void G__setup_memvarTBuffer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TBuffer));
   { TBuffer *p; p=(TBuffer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMode=",0,"Read or write mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersion=",0,"Buffer format version");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufSize=",0,"Size of buffer");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBuffer=",0,"Buffer used to store objects");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBufCur=",0,"Current position in buffer");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBufMax=",0,"End of buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObject),-1,-1,2,"fParent=",0,"Pointer to parent object owning this buffer");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReAllocCharFun_t"),-1,2,"fReAllocFunc=",0,"! Realloc function to be used when extending the buffer.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),G__defined_typename("CacheList_t"),-1,2,"fCacheStack=",0,"Stack of pointers to the cache where to temporarily store the value of 'missing' data members");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffercLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TBuffer::kRead).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffercLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TBuffer::kWrite).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsOwner=%lldLL",(long long)TBuffer::kIsOwner).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCannotHandleMemberWiseStreaming=%lldLL",(long long)TBuffer::kCannotHandleMemberWiseStreaming).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kInitialSize=%lldLL",(long long)TBuffer::kInitialSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kMinimalSize=%lldLL",(long long)TBuffer::kMinimalSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDirectory */
static void G__setup_memvarTDirectory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TDirectory));
   { TDirectory *p; p=(TDirectory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObject),-1,-1,2,"fMother=",0,"pointer to mother of the directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TList),-1,-1,2,"fList=",0,"List of objects in memory");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TUUID),-1,-1,2,"fUUID=",0,"Unique identifier");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,2,"fPathBuffer=",0,"!Buffer for GetPath() function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TDirectorycLcLTContext),-1,-1,2,"fContext=",0,"!Pointer to a list of TContext object pointing to this TDirectory");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgAddDirectory=",0,"!flag to add histograms, graphs,etc to the directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootIOCtor */
static void G__setup_memvarTRootIOCtor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TRootIOCtor));
   { TRootIOCtor *p; p=(TRootIOCtor*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* ROOT */
static void G__setup_memvarROOT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_ROOT));
   {
   }
   G__tag_memvar_reset();
}


   /* TBrowser */
static void G__setup_memvarTBrowser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TBrowser));
   { TBrowser *p; p=(TBrowser*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObject),-1,-1,4,"fLastSelectedObject=",0,"!The last TObject selected by user");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp),-1,-1,2,"fImp=",0,"!Window system specific browser implementation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TBrowserTimer),-1,-1,2,"fTimer=",0,"!Browser's timer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TContextMenu),-1,-1,2,"fContextMenu=",0,"!Context menu pointer");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNeedRefresh=",0,"True if the browser needs refresh");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBrowsercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoHidden=%lldLL",(long long)TBrowser::kNoHidden).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TApplicationImp */
static void G__setup_memvarTApplicationImp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp));
   { TApplicationImp *p; p=(TApplicationImp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,2,"fApplicationName=",0,"application name");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TApplication */
static void G__setup_memvarTApplication(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TApplication));
   { TApplication *p; p=(TApplication*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kProcessRemotely=%lldLL",(long long)TApplication::kProcessRemotely).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kDefaultApplication=%lldLL",(long long)TApplication::kDefaultApplication).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEExitOnException),-1,-2,1,G__FastAllocString(2048).Format("kDontExit=%lldLL",(long long)TApplication::kDontExit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEExitOnException),-1,-2,1,G__FastAllocString(2048).Format("kExit=%lldLL",(long long)TApplication::kExit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEExitOnException),-1,-2,1,G__FastAllocString(2048).Format("kAbort=%lldLL",(long long)TApplication::kAbort).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fArgc=",0,"Number of com   mand line arguments");
   G__memvar_setup((void*)0,67,2,0,-1,-1,-1,4,"fArgv=",0,"Command line arguments");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp),-1,-1,4,"fAppImp=",0,"!Window system specific application implementation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsRunning=",0,"True when in event loop (Run() has been called)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReturnFromRun=",0,"When true return from Run()");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNoLog=",0,"Do not process logon and logoff macros");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNoLogo=",0,"Do not show splash screen and welcome message");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fQuit=",0,"Exit after having processed input files");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseMemstat=",0,"Run with TMemStat enabled");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObjArray),-1,-1,4,"fFiles=",0,"Array of input files (TObjString's) specified via argv");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fWorkDir=",0,"Working directory specified via argv");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fIdleCommand=",0,"Command to execute while application is idle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TTimer),-1,-1,4,"fIdleTimer=",0,"Idle timer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TSignalHandler),-1,-1,4,"fSigHandler=",0,"Interrupt handler");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEExitOnException),-1,-1,4,"fExitOnException=",0,"Exit on exception option");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgGraphNeeded=",0,"True if graphics libs need to be initialized");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgGraphInit=",0,"True if graphics libs initialized");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TApplication),-1,-1,2,"fAppRemote=",0,"Current remote application, if defined");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TList),-1,-2,2,"fgApplications=",0,"List of available applications");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAtt3D */
static void G__setup_memvarTAtt3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAtt3D));
   { TAtt3D *p; p=(TAtt3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttAxis */
static void G__setup_memvarTAttAxis(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttAxis));
   { TAttAxis *p; p=(TAttAxis*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdivisions=",0,"Number of divisions(10000*n3 + 100*n2 + n1)");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fAxisColor=",0,"color of the line axis");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fLabelColor=",0,"color of labels");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fLabelFont=",0,"font for labels");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLabelOffset=",0,"offset of labels");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLabelSize=",0,"size of labels");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTickLength=",0,"length of tick marks");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTitleOffset=",0,"offset of axis title");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTitleSize=",0,"size of axis title");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fTitleColor=",0,"color of axis title");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fTitleFont=",0,"font for axis title");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttBBox */
static void G__setup_memvarTAttBBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttBBox));
   { TAttBBox *p; p=(TAttBBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBBox=",0,"! Dynamic Float_t[6] X(min,max), Y(min,max), Z(min,max)");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttFill */
static void G__setup_memvarTAttFill(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttFill));
   { TAttFill *p; p=(TAttFill*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFillColor=",0,"fill area color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fFillStyle=",0,"fill area style");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttLine */
static void G__setup_memvarTAttLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttLine));
   { TAttLine *p; p=(TAttLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fLineColor=",0,"line color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fLineStyle=",0,"line style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,2,"fLineWidth=",0,"line width");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttMarker */
static void G__setup_memvarTAttMarker(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttMarker));
   { TAttMarker *p; p=(TAttMarker*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fMarkerColor=",0,"Marker color index");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fMarkerStyle=",0,"Marker style");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Size_t"),-1,2,"fMarkerSize=",0,"Marker size");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttPad */
static void G__setup_memvarTAttPad(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttPad));
   { TAttPad *p; p=(TAttPad*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLeftMargin=",0,"LeftMargin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRightMargin=",0,"RightMargin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBottomMargin=",0,"BottomMargin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTopMargin=",0,"TopMargin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fXfile=",0,"X position where to draw the file name");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fYfile=",0,"Y position where to draw the file name");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAfile=",0,"Alignment for the file name");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fXstat=",0,"X position where to draw the statistics");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fYstat=",0,"Y position where to draw the statistics");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAstat=",0,"Alignment for the statistics");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFrameFillColor=",0,"pad frame fill color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFrameLineColor=",0,"pad frame line color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fFrameFillStyle=",0,"pad frame fill style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fFrameLineStyle=",0,"pad frame line style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,2,"fFrameLineWidth=",0,"pad frame line width");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,2,"fFrameBorderSize=",0,"pad frame border size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFrameBorderMode=",0,"pad frame border mode");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttText */
static void G__setup_memvarTAttText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttText));
   { TAttText *p; p=(TAttText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTextAngle=",0,"Text angle");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTextSize=",0,"Text size");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fTextAlign=",0,"Text alignment");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fTextColor=",0,"Text color index");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Font_t"),-1,2,"fTextFont=",0,"Text font number");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBenchmark */
static void G__setup_memvarTBenchmark(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TBenchmark));
   { TBenchmark *p; p=(TBenchmark*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbench=",0,"Number of active benchmarks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNmax=",0,"Maximum number of benchmarks initialized");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,2,"fNames=",0,"[fNbench] Names of benchmarks");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRealTime=",0,"[fNbench] Real Time");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fCpuTime=",0,"[fNbench] Cpu Time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TStopwatch),-1,-1,2,"fTimer=",0,"Timers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBrowserImp */
static void G__setup_memvarTBrowserImp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp));
   { TBrowserImp *p; p=(TBrowserImp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TBrowser),-1,-1,2,"fBrowser=",0,"TBrowser associated with this implementation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowCycles=",0,"Show object cycle numbers in browser");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TContextMenu */
static void G__setup_memvarTContextMenu(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TContextMenu));
   { TContextMenu *p; p=(TContextMenu*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp),-1,-1,2,"fContextMenuImp=",0,"!Context menu system specific implementation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TFunction),-1,-1,2,"fSelectedMethod=",0,"selected method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObject),-1,-1,2,"fSelectedObject=",0,"selected object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObject),-1,-1,2,"fCalledObject=",0,"object to call");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClassMenuItem),-1,-1,2,"fSelectedMenuItem=",0,"selected class menu item");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),-1,-1,2,"fSelectedCanvas=",0,"selected canvas (if exist)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad),-1,-1,2,"fSelectedPad=",0,"selected pad (if exist)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TBrowser),-1,-1,2,"fBrowser=",0,"selected browser (if exist)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBuffer3D */
static void G__setup_memvarTBuffer3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D));
   { TBuffer3D *p; p=(TBuffer3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,1,-1,G__defined_typename("Int_t"),-1,4,"fType=",0,"Primitive type - predefined ones in TBuffer3DTypes.h");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNbPnts=",0,"Number of points describing the shape");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNbSegs=",0,"Number of segments describing the shape");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNbPols=",0,"Number of polygons describing the shape");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fPntsCapacity=",0,"Current capacity of fPnts space");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSegsCapacity=",0,"Current capacity of fSegs space");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fPolsCapacity=",0,"Current capacity of fSegs space");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSections=",0,"Section validity flags");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgCSLevel=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLEBoolOpCode),-1,-2,1,G__FastAllocString(2048).Format("kCSUnion=%lldLL",(long long)TBuffer3D::kCSUnion).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLEBoolOpCode),-1,-2,1,G__FastAllocString(2048).Format("kCSIntersection=%lldLL",(long long)TBuffer3D::kCSIntersection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLEBoolOpCode),-1,-2,1,G__FastAllocString(2048).Format("kCSDifference=%lldLL",(long long)TBuffer3D::kCSDifference).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLEBoolOpCode),-1,-2,1,G__FastAllocString(2048).Format("kCSNoOp=%lldLL",(long long)TBuffer3D::kCSNoOp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TBuffer3D::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kCore=%lldLL",(long long)TBuffer3D::kCore).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kBoundingBox=%lldLL",(long long)TBuffer3D::kBoundingBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kShapeSpecific=%lldLL",(long long)TBuffer3D::kShapeSpecific).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kRawSizes=%lldLL",(long long)TBuffer3D::kRawSizes).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kRaw=%lldLL",(long long)TBuffer3D::kRaw).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TBuffer3DcLcLESection),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TBuffer3D::kAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fID)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TObject),-1,-1,1,"fID=",0,"ID/object generating buffer - see TVirtualViewer3D for setting");
   G__memvar_setup((void*)((long)(&p->fColor)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fColor=",0,"Color index");
   G__memvar_setup((void*)((long)(&p->fTransparency)-(long)(p)),115,0,0,-1,G__defined_typename("Short_t"),-1,1,"fTransparency=",0,"Percentage transparency [0,100]");
   G__memvar_setup((void*)((long)(&p->fLocalFrame)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fLocalFrame=",0,"True = Local, False = Master reference frame");
   G__memvar_setup((void*)((long)(&p->fReflection)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fReflection=",0,"Matrix is reflection - TODO: REMOVE when OGL viewer rewokred to local frame");
   G__memvar_setup((void*)((long)(&p->fLocalMaster)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fLocalMaster[16]=",0,"Local->Master Matrix - identity if master frame");
   G__memvar_setup((void*)((long)(&p->fBBVertex)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fBBVertex[8][3]=",0,"8 verticies defining bounding box. ");
   G__memvar_setup((void*)((long)(&p->fPnts)-(long)(p)),68,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPnts=",0,"x0, y0, z0, x1, y1, z1, ..... ..... ....");
   G__memvar_setup((void*)((long)(&p->fSegs)-(long)(p)),73,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSegs=",0,"c0, p0, q0, c1, p1, q1, ..... ..... ....  ");
   G__memvar_setup((void*)((long)(&p->fPols)-(long)(p)),73,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPols=",0,"c0, n0, s0, s1, ... sn, c1, n1, s0, ... sn");
   G__memvar_setup((void*)((long)(&p->fPhysicalID)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fPhysicalID=",0,"Unique replica ID.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCanvasImp */
static void G__setup_memvarTCanvasImp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp));
   { TCanvasImp *p; p=(TCanvasImp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TCanvas),-1,-1,2,"fCanvas=",0,"TCanvas associated with this implementation");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TColor */
static void G__setup_memvarTColor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TColor));
   { TColor *p; p=(TColor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumber=",0,"Color number identifier");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRed=",0,"Fraction of Red");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fGreen=",0,"Fraction of Green");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBlue=",0,"Fraction of Blue");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fHue=",0,"Hue");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLight=",0,"Light");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSaturation=",0,"Saturation");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha=",0,"Alpha (transparency)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgGrayscaleMode=",0,"if set, GetColor will return grayscale");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgInitDone=",0,"kTRUE once ROOT colors have been initialized");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TArrayI),-1,-2,4,"fgPalette=",0,"Color palette");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TContextMenuImp */
static void G__setup_memvarTContextMenuImp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp));
   { TContextMenuImp *p; p=(TContextMenuImp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TContextMenu),-1,-1,2,"fContextMenu=",0,"TContextMenu associated with this implementation");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualPad */
static void G__setup_memvarTVirtualPad(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad));
   { TVirtualPad *p; p=(TVirtualPad*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fResizing=",0,"!true when resizing the pad");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TControlBarImp */
static void G__setup_memvarTControlBarImp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp));
   { TControlBarImp *p; p=(TControlBarImp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TControlBar),-1,-1,2,"fControlBar=",0,"TControlBar associated with this implementation");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXpos=",0,"Initial x position");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYpos=",0,"Initial y position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TControlBarButton),-1,-1,2,"fClicked=",0,"Last clicked button ");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDatime */
static void G__setup_memvarTDatime(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TDatime));
   { TDatime *p; p=(TDatime*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDatime=",0,"Date (relative to 1995) + time");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEnv */
static void G__setup_memvarTEnv(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TEnv));
   { TEnv *p; p=(TEnv*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_THashList),-1,-1,4,"fTable=",0,"hash table containing env records");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fRcName=",0,"resource file base name");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIgnoreDup=",0,"ignore duplicates, don't issue warning");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEnvRec */
static void G__setup_memvarTEnvRec(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TEnvRec));
   { TEnvRec *p; p=(TEnvRec*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fName=",0,"env rec key name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fType=",0,"env rec type");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fValue=",0,"env rec value");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel),-1,-1,4,"fLevel=",0,"env rec level");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fModified=",0,"if env rec has been modified");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TInspectorImp */
static void G__setup_memvarTInspectorImp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp));
   { TInspectorImp *p; p=(TInspectorImp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGuiFactory */
static void G__setup_memvarTGuiFactory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory));
   { TGuiFactory *p; p=(TGuiFactory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFileHandler */
static void G__setup_memvarTFileHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TFileHandler));
   { TFileHandler *p; p=(TFileHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fFileNum=",0,"File descriptor");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fMask=",0,"Event interest mask, either bit 1 (read), 2 (write) or both can be set");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fReadyMask=",0,"Readiness mask, either bit 1 (read), 2 (write) or both can be set");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TFileHandlercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TFileHandler::kRead).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TFileHandlercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TFileHandler::kWrite).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStyle */
static void G__setup_memvarTStyle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle));
   { TStyle *p; p=(TStyle*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TAttAxis),-1,-1,4,"fXaxis=",0,"X axis attributes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TAttAxis),-1,-1,4,"fYaxis=",0,"Y axis attributes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TAttAxis),-1,-1,4,"fZaxis=",0,"Z axis attributes");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBarWidth=",0,"width of bar for graphs");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBarOffset=",0,"offset of bar for graphs");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColorModelPS=",0,"PostScript color model: 0 = RGB, 1 = CMYK");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDrawBorder=",0,"flag to draw border(=1) or not (0)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptLogx=",0,"=1 if log scale in X");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptLogy=",0,"=1 if log scale in y");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptLogz=",0,"=1 if log scale in z");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptDate=",0,"=1 if date option is selected");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptStat=",0,"=1 if option Stat is selected");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptTitle=",0,"=1 if option Title is selected");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptFile=",0,"=1 if option File is selected");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptFit=",0,"=1 if option Fit is selected");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fShowEventStatus=",0,"Show event status panel");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fShowEditor=",0,"Show pad editor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fShowToolBar=",0,"Show toolbar");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumberContours=",0,"default number of contours for 2-d plots");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TAttText),-1,-1,4,"fAttDate=",0,"canvas date attribute");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDateX=",0,"X position of the date in the canvas (in NDC)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDateY=",0,"Y position of the date in the canvas (in NDC)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEndErrorSize=",0,"Size of lines at the end of error bars");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fErrorX=",0,"per cent of bin width for errors along X");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fFuncColor=",0,"function color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fFuncStyle=",0,"function style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fFuncWidth=",0,"function line width");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fGridColor=",0,"grid line color (if 0 use axis line color)");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fGridStyle=",0,"grid line style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fGridWidth=",0,"grid line width");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fLegendBorderSize=",0,"TLegend box border size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHatchesLineWidth=",0,"hatches line width for hatch styles > 3100");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHatchesSpacing=",0,"hatches spacing for hatch styles > 3100");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fFrameFillColor=",0,"pad frame fill color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fFrameLineColor=",0,"pad frame line color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fFrameFillStyle=",0,"pad frame fill style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fFrameLineStyle=",0,"pad frame line style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fFrameLineWidth=",0,"pad frame line width");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fFrameBorderSize=",0,"pad frame border size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFrameBorderMode=",0,"pad frame border mode");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fHistFillColor=",0,"histogram fill color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fHistLineColor=",0,"histogram line color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fHistFillStyle=",0,"histogram fill style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fHistLineStyle=",0,"histogram line style");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fHistLineWidth=",0,"histogram line width");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHistMinimumZero=",0,"true if default minimum is 0, false if minimum is automatic");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHistTopMargin=",0,"margin between histogram's top and pad's top");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCanvasPreferGL=",0,"if true, rendering in canvas is with GL");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fCanvasColor=",0,"canvas color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fCanvasBorderSize=",0,"canvas border size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanvasBorderMode=",0,"canvas border mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanvasDefH=",0,"default canvas height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanvasDefW=",0,"default canvas width");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanvasDefX=",0,"default canvas top X position");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanvasDefY=",0,"default canvas top Y position");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fPadColor=",0,"pad color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fPadBorderSize=",0,"pad border size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPadBorderMode=",0,"pad border mode");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPadBottomMargin=",0,"pad bottom margin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPadTopMargin=",0,"pad top margin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPadLeftMargin=",0,"pad left margin");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPadRightMargin=",0,"pad right margin");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPadGridX=",0,"true to get the grid along X");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPadGridY=",0,"true to get the grid along Y");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPadTickX=",0,"=1 to set special pad ticks along X");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPadTickY=",0,"=1 to set special pad ticks along Y");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPaperSizeX=",0,"PostScript paper size along X");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPaperSizeY=",0,"PostScript paper size along Y");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fScreenFactor=",0,"Multiplication factor for canvas size and position");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fStatColor=",0,"stat fill area color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fStatTextColor=",0,"stat text color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fStatBorderSize=",0,"border size of Stats PaveLabel");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fStatFont=",0,"font style of Stats PaveLabel");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStatFontSize=",0,"font size in pixels for fonts with precision type 3");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fStatStyle=",0,"fill area style of Stats PaveLabel");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fStatFormat=",0,"Printing format for stats");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStatX=",0,"X position of top right corner of stat box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStatY=",0,"Y position of top right corner of stat box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStatW=",0,"width of stat box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fStatH=",0,"height of stat box");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStripDecimals=",0,"Strip decimals in axis labels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTitleAlign=",0,"title box alignment");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fTitleColor=",0,"title fill area color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fTitleTextColor=",0,"title text color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Width_t"),-1,4,"fTitleBorderSize=",0,"border size of Title PavelLabel");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fTitleFont=",0,"font style of Title PaveLabel");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTitleFontSize=",0,"font size in pixels for fonts with precision type 3");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,4,"fTitleStyle=",0,"fill area style of title PaveLabel");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTitleX=",0,"X position of top left corner of title box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTitleY=",0,"Y position of top left corner of title box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTitleW=",0,"width of title box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTitleH=",0,"height of title box");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLegoInnerR=",0,"Inner radius for cylindrical legos");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fLineStyle[30]=",0,"String describing line style i (for postScript)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fHeaderPS=",0,"User defined additional Postscript header");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fTitlePS=",0,"User defined Postscript file title");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fFitFormat=",0,"Printing format for fit parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-1,4,"fPaintTextFormat=",0,"Printing format for TH2::PaintText");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLineScalePS=",0,"Line scale factor when drawing lines on Postscript");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTimeOffset=",0,"Time offset to the beginning of an axis");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsReading=",0,"!Set to FALSE when userclass::UseCurrentStyle is called by the style manager");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TStylecLcLEPaperSize),-1,-2,1,G__FastAllocString(2048).Format("kA4=%lldLL",(long long)TStyle::kA4).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TStylecLcLEPaperSize),-1,-2,1,G__FastAllocString(2048).Format("kUSLetter=%lldLL",(long long)TStyle::kUSLetter).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualFFT */
static void G__setup_memvarTVirtualFFT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT));
   { TVirtualFFT *p; p=(TVirtualFFT*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT),-1,-2,2,"fgFFT=",0,"current transformer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-2,2,"fgDefault=",0,"default transformer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualViewer3D */
static void G__setup_memvarTVirtualViewer3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D));
   { TVirtualViewer3D *p; p=(TVirtualViewer3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualGLPainter */
static void G__setup_memvarTVirtualGLPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualGLPainter));
   { TVirtualGLPainter *p; p=(TVirtualGLPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualGLManip */
static void G__setup_memvarTVirtualGLManip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualGLManip));
   { TVirtualGLManip *p; p=(TVirtualGLManip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLManager */
static void G__setup_memvarTGLManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TGLManager));
   { TGLManager *p; p=(TGLManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPaintDevice */
static void G__setup_memvarTGLPaintDevice(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TGLPaintDevice));
   { TGLPaintDevice *p; p=(TGLPaintDevice*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualPadEditor */
static void G__setup_memvarTVirtualPadEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadEditor));
   { TVirtualPadEditor *p; p=(TVirtualPadEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadEditor),-1,-2,2,"fgPadEditor=",0,"singleton editor dialog");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base1LN_TString),-1,-2,2,"fgEditorName=",0,"name of the default pad editor \"Ged\"");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualX */
static void G__setup_memvarTVirtualX(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX));
   { TVirtualX *p; p=(TVirtualX*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEDrawMode),-1,-2,1,G__FastAllocString(2048).Format("kCopy=%lldLL",(long long)TVirtualX::kCopy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEDrawMode),-1,-2,1,G__FastAllocString(2048).Format("kXor=%lldLL",(long long)TVirtualX::kXor).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEDrawMode),-1,-2,1,G__FastAllocString(2048).Format("kInvert=%lldLL",(long long)TVirtualX::kInvert).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEBoxMode),-1,-2,1,G__FastAllocString(2048).Format("kHollow=%lldLL",(long long)TVirtualX::kHollow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEBoxMode),-1,-2,1,G__FastAllocString(2048).Format("kFilled=%lldLL",(long long)TVirtualX::kFilled).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLETextMode),-1,-2,1,G__FastAllocString(2048).Format("kClear=%lldLL",(long long)TVirtualX::kClear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLETextMode),-1,-2,1,G__FastAllocString(2048).Format("kOpaque=%lldLL",(long long)TVirtualX::kOpaque).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLETextSetMode),-1,-2,1,G__FastAllocString(2048).Format("kCheck=%lldLL",(long long)TVirtualX::kCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLETextSetMode),-1,-2,1,G__FastAllocString(2048).Format("kLoad=%lldLL",(long long)TVirtualX::kLoad).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEDrawMode),-1,-1,2,"fDrawMode=",0,"Drawing mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualPadPainter */
static void G__setup_memvarTVirtualPadPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPainter));
   { TVirtualPadPainter *p; p=(TVirtualPadPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPaintercLcLEBoxMode),-1,-2,1,G__FastAllocString(2048).Format("kHollow=%lldLL",(long long)TVirtualPadPainter::kHollow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPaintercLcLEBoxMode),-1,-2,1,G__FastAllocString(2048).Format("kFilled=%lldLL",(long long)TVirtualPadPainter::kFilled).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPaintercLcLETextMode),-1,-2,1,G__FastAllocString(2048).Format("kClear=%lldLL",(long long)TVirtualPadPainter::kClear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPaintercLcLETextMode),-1,-2,1,G__FastAllocString(2048).Format("kOpaque=%lldLL",(long long)TVirtualPadPainter::kOpaque).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualPS */
static void G__setup_memvarTVirtualPS(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS));
   { TVirtualPS *p; p=(TVirtualPS*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNByte=",0,"Number of bytes written in the file (PDF)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLenBuffer=",0,"Buffer length");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSizBuffer=",0,"Buffer size");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPrinted=",0,"True when a page must be printed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("ofstream"),-1,2,"fStream=",0,"File stream identifier");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fBuffer=",0,"File buffer");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-1,2,"fImplicitCREsc=",0,"Escape symbol before enforced new line");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Base1() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTBuffer(void) {
   /* TBuffer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TBuffer));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("Read",380,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"C - - 10 - name i - 'Int_t' 0 - opt "
"i - 'Int_t' 0 - bufs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8, 
"C - - 10 - name i - 'Int_t' 0 - opt "
"i - 'Int_t' 0 - bufs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBufferVersion",1632,G__G__Base1_7_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReading",886,G__G__Base1_7_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsWriting",928,G__G__Base1_7_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadMode",1069,G__G__Base1_7_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWriteMode",1212,G__G__Base1_7_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBuffer",902,G__G__Base1_7_0_15, 121, -1, -1, 0, 4, 1, 1, 0, 
"Y - - 0 - buf h - 'UInt_t' 0 '0' bufsiz "
"g - 'Bool_t' 0 'kTRUE' adopt Y - 'ReAllocCharFun_t' 0 '0' reallocfunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReAllocFunc",1358,G__G__Base1_7_0_16, 89, -1, G__defined_typename("ReAllocCharFun_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReAllocFunc",1370,G__G__Base1_7_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'ReAllocCharFun_t' 0 '0' reallocfunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBufferOffset",1517,G__G__Base1_7_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParent",918,G__G__Base1_7_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Base1_7_0_20, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Buffer",602,G__G__Base1_7_0_21, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferSize",1013,G__G__Base1_7_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DetachBuffer",1187,G__G__Base1_7_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Length",610,G__G__Base1_7_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Expand",608,G__G__Base1_7_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newsize", "expand buffer to newsize", (void*) NULL, 0);
   G__memfunc_setup("CheckObject",1077,G__G__Base1_7_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckObject",1077,G__G__Base1_7_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - ptrClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadBuf",665,G__G__Base1_7_0_28, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"Y - - 0 - buf i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteBuf",808,G__G__Base1_7_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 10 - buf i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadString",1011,G__G__Base1_7_0_30, 67, -1, -1, 0, 2, 1, 1, 0, 
"C - - 0 - s i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteString",1154,G__G__Base1_7_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVersionOwner",1553,G__G__Base1_7_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMapCount",1095,G__G__Base1_7_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMappedObject",1486,G__G__Base1_7_0_34, 121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 0 - tag Y - - 1 - ptr "
"U 'TClass' - 1 - ClassPtr", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MapObject",885,G__G__Base1_7_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj h - 'UInt_t' 0 '1' offset", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MapObject",885,G__G__Base1_7_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - cl "
"h - 'UInt_t' 0 '1' offset", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Reset",515,G__G__Base1_7_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InitMap",690,G__G__Base1_7_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResetMap",801,G__G__Base1_7_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetReadParam",1177,G__G__Base1_7_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mapsize", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetWriteParam",1320,G__G__Base1_7_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mapsize", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckByteCount",1403,G__G__Base1_7_0_42, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - startpos h - 'UInt_t' 0 - bcnt "
"U 'TClass' - 10 - clss", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckByteCount",1403,G__G__Base1_7_0_43, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - startpos h - 'UInt_t' 0 - bcnt "
"C - - 10 - classname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetByteCount",1225,G__G__Base1_7_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - cntpos g - 'Bool_t' 0 'kFALSE' packInVersion", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SkipVersion",1149,G__G__Base1_7_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 '0' cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadVersion",1122,G__G__Base1_7_0_46, 115, -1, G__defined_typename("Version_t"), 0, 3, 1, 1, 0, 
"H - 'UInt_t' 0 '0' start H - 'UInt_t' 0 '0' bcnt "
"U 'TClass' - 10 '0' cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteVersion",1265,G__G__Base1_7_0_47, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl g - 'Bool_t' 0 'kFALSE' useBcnt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteVersionMemberWise",2273,G__G__Base1_7_0_48, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl g - 'Bool_t' 0 'kFALSE' useBcnt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadObjectAny",1275,G__G__Base1_7_0_49, 89, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cast", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SkipObjectAny",1302,G__G__Base1_7_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TagStreamerInfo",1515,G__G__Base1_7_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IncrementLevel",1437,G__G__Base1_7_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetStreamerElementNumber",2466,G__G__Base1_7_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DecrementLevel",1423,G__G__Base1_7_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ClassBegin",987,G__G__Base1_7_0_55, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - - s - 'Version_t' 0 '-1' -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ClassEnd",781,G__G__Base1_7_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ClassMember",1102,G__G__Base1_7_0_57, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - - C - - 10 '0' - "
"i - 'Int_t' 0 '-1' - i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetInfo",684,G__G__Base1_7_0_58, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualStreamerInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PeekDataCache",1235,G__G__Base1_7_0_59, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopDataCache",1149,G__G__Base1_7_0_60, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PushDataCache",1262,G__G__Base1_7_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualArray' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadClass",882,G__G__Base1_7_0_62, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 '0' cl H - 'UInt_t' 0 '0' objTag", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteClass",1025,G__G__Base1_7_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadObject",979,G__G__Base1_7_0_64, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 0, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteObject",1122,G__G__Base1_7_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteObjectAny",1418,G__G__Base1_7_0_66, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"Y - - 10 - obj U 'TClass' - 10 - ptrClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPidOffset",1188,G__G__Base1_7_0_67, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPidOffset",1200,G__G__Base1_7_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - offset", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBufferDisplacement",2131,G__G__Base1_7_0_69, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBufferDisplacement",2143,G__G__Base1_7_0_70, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBufferDisplacement",2143,G__G__Base1_7_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - skipped", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFloat16",985,G__G__Base1_7_0_72, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFloat16",1128,G__G__Base1_7_0_73, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadDouble32",1084,G__G__Base1_7_0_74, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteDouble32",1227,G__G__Base1_7_0_75, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWithFactor",1399,G__G__Base1_7_0_76, 121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 0 - ptr d - 'Double_t' 0 - factor "
"d - 'Double_t' 0 - minvalue", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWithNbits",1304,G__G__Base1_7_0_77, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - ptr i - 'Int_t' 0 - nbits", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWithFactor",1399,G__G__Base1_7_0_78, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - ptr d - 'Double_t' 0 - factor "
"d - 'Double_t' 0 - minvalue", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWithNbits",1304,G__G__Base1_7_0_79, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - ptr i - 'Int_t' 0 - nbits", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_80, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "G - 'Bool_t' 1 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_81, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Char_t' 1 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_82, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "B - 'UChar_t' 1 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_83, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "S - 'Short_t' 1 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_84, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "R - 'UShort_t' 1 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_85, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "I - 'Int_t' 1 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_86, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "H - 'UInt_t' 1 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_87, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "L - 'Long_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_88, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "K - 'ULong_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_89, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "N - 'Long64_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_90, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "M - 'ULong64_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_91, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "F - 'Float_t' 1 - f", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Base1_7_0_92, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 1 - d", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArrayFloat16",1496,G__G__Base1_7_0_93, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"F - 'Float_t' 1 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArrayDouble32",1595,G__G__Base1_7_0_94, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 1 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_95, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "G - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_96, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_97, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "B - 'UChar_t' 0 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_98, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "S - 'Short_t' 0 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_99, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "R - 'UShort_t' 0 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_100, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "I - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_101, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_102, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "L - 'Long_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_103, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "K - 'ULong_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_104, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "N - 'Long64_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_105, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "M - 'ULong64_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_106, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "F - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArray",1507,G__G__Base1_7_0_107, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArrayFloat16",2112,G__G__Base1_7_0_108, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadStaticArrayDouble32",2211,G__G__Base1_7_0_109, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_110, 121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 0 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_111, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 0 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArrayString",1920,G__G__Base1_7_0_112, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 0 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_113, 121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 0 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_114, 121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 0 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_115, 121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 0 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_116, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_117, 121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 0 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_118, 121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_119, 121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_120, 121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_121, 121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 0 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_122, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_123, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArrayFloat16",1894,G__G__Base1_7_0_124, 121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 0 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArrayDouble32",1993,G__G__Base1_7_0_125, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_126, 121, -1, -1, 0, 5, 1, 1, 0, 
"Y - - 0 - start U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n U 'TMemberStreamer' - 0 '0' s "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFastArray",1289,G__G__Base1_7_0_127, 121, -1, -1, 0, 6, 1, 1, 0, 
"Y - - 2 - startp U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n g - 'Bool_t' 0 'kFALSE' isPreAlloc "
"U 'TMemberStreamer' - 0 '0' s U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_128, 121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 10 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_129, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_130, 121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_131, 121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_132, 121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_133, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_134, 121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_135, 121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_136, 121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_137, 121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_138, 121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_139, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArray",1034,G__G__Base1_7_0_140, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArrayFloat16",1639,G__G__Base1_7_0_141, 121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteArrayDouble32",1738,G__G__Base1_7_0_142, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_143, 121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 10 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_144, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArrayString",2063,G__G__Base1_7_0_145, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_146, 121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_147, 121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_148, 121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_149, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_150, 121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_151, 121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_152, 121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_153, 121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_154, 121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_155, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_156, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArrayFloat16",2037,G__G__Base1_7_0_157, 121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArrayDouble32",2136,G__G__Base1_7_0_158, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_159, 121, -1, -1, 0, 4, 1, 1, 0, 
"Y - - 0 - start U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n U 'TMemberStreamer' - 0 '0' s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFastArray",1432,G__G__Base1_7_0_160, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 2 - startp U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n g - 'Bool_t' 0 'kFALSE' isPreAlloc "
"U 'TMemberStreamer' - 0 '0' s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StreamObject",1219,G__G__Base1_7_0_161, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - obj u 'type_info' - 11 - typeinfo "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StreamObject",1219,G__G__Base1_7_0_162, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - obj C - - 10 - className "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StreamObject",1219,G__G__Base1_7_0_163, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - obj U 'TClass' - 10 - cl "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StreamObject",1219,G__G__Base1_7_0_164, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadBool",776,G__G__Base1_7_0_165, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadChar",762,G__G__Base1_7_0_166, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 1 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadUChar",847,G__G__Base1_7_0_167, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 1 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadShort",908,G__G__Base1_7_0_168, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 1 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadUShort",993,G__G__Base1_7_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 1 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadInt",679,G__G__Base1_7_0_170, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 1 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadUInt",764,G__G__Base1_7_0_171, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 1 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadLong",780,G__G__Base1_7_0_172, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadULong",865,G__G__Base1_7_0_173, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadLong64",886,G__G__Base1_7_0_174, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadULong64",971,G__G__Base1_7_0_175, 121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 1 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFloat",882,G__G__Base1_7_0_176, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 1 - f", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadDouble",983,G__G__Base1_7_0_177, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 1 - d", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadCharP",842,G__G__Base1_7_0_178, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadTString",1095,G__G__Base1_7_0_179, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 1 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteBool",919,G__G__Base1_7_0_180, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteChar",905,G__G__Base1_7_0_181, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteUChar",990,G__G__Base1_7_0_182, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteShort",1051,G__G__Base1_7_0_183, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteUShort",1136,G__G__Base1_7_0_184, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteInt",822,G__G__Base1_7_0_185, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteUInt",907,G__G__Base1_7_0_186, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteLong",923,G__G__Base1_7_0_187, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteULong",1008,G__G__Base1_7_0_188, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteLong64",1029,G__G__Base1_7_0_189, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteULong64",1114,G__G__Base1_7_0_190, 121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 0 - l", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFloat",1025,G__G__Base1_7_0_191, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteDouble",1126,G__G__Base1_7_0_192, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteCharP",985,G__G__Base1_7_0_193, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteTString",1238,G__G__Base1_7_0_194, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLastProcessID",1568,G__G__Base1_7_0_195, 85, G__get_linked_tagnum(&G__G__Base1LN_TProcessID), -1, 0, 1, 1, 1, 8, "U 'TRefTable' - 0 - reftable", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTRefExecId",1219,G__G__Base1_7_0_196, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadProcessID",1256,G__G__Base1_7_0_197, 85, G__get_linked_tagnum(&G__G__Base1LN_TProcessID), -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - pidf", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteProcessID",1399,G__G__Base1_7_0_198, 114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 0, "U 'TProcessID' - 0 - pid", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ForceWriteInfo",1414,G__G__Base1_7_0_199, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ForceWriteInfoClones",2026,G__G__Base1_7_0_200, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClonesArray' - 0 - a", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadClones",992,G__G__Base1_7_0_201, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TClonesArray' - 0 - a i - 'Int_t' 0 - nobjects "
"s - 'Version_t' 0 - objvers", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteClones",1135,G__G__Base1_7_0_202, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - a i - 'Int_t' 0 - nobjects", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadClassEmulated",1699,G__G__Base1_7_0_203, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - object "
"U 'TClass' - 10 '0' onfile_class", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadClassBuffer",1484,G__G__Base1_7_0_204, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - pointer "
"U 'TClass' - 10 '0' onfile_class", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadClassBuffer",1484,G__G__Base1_7_0_205, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - pointer "
"i - 'Int_t' 0 - version h - 'UInt_t' 0 - start "
"h - 'UInt_t' 0 - count U 'TClass' - 10 '0' onfile_class", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteClassBuffer",1627,G__G__Base1_7_0_206, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl Y - - 0 - pointer", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadSequence",1205,G__G__Base1_7_0_207, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TStreamerInfoActions::TActionSequence' - 11 - sequence Y - - 0 - object", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadSequenceVecPtr",1801,G__G__Base1_7_0_208, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TStreamerInfoActions::TActionSequence' - 11 - sequence Y - - 0 - start_collection "
"Y - - 0 - end_collection", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadSequence",1205,G__G__Base1_7_0_209, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TStreamerInfoActions::TActionSequence' - 11 - sequence Y - - 0 - start_collection "
"Y - - 0 - end_collection", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetClass",790,G__G__Base1_7_0_210, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 1, 3, 1, 0, "u 'type_info' - 11 - typeinfo", (char*)NULL, (void*) G__func2void( (TClass* (*)(const type_info&))(&TBuffer::GetClass) ), 0);
   G__memfunc_setup("GetClass",790,G__G__Base1_7_0_211, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 1, 3, 1, 0, "C - - 10 - className", (char*)NULL, (void*) G__func2void( (TClass* (*)(const char*))(&TBuffer::GetClass) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_7_0_212, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBuffer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_7_0_213, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBuffer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_7_0_214, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBuffer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_7_0_215, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBuffer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_7_0_219, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_7_0_220, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBuffer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_7_0_221, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBuffer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_7_0_222, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBuffer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_7_0_223, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBuffer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBuffer", 812, G__G__Base1_7_0_224, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDirectory(void) {
   /* TDirectory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TDirectory));
   G__memfunc_setup("cd1",248,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cd1",216,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 2, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanTargets",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillFullPath",1191,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TString' - 1 - buf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterContext",1578,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDirectory::TContext' - 0 - ctxt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnregisterContext",1805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDirectory::TContext' - 0 - ctxt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDirectory",1033,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TDirectory), -1, 0, 1, 1, 2, 0, "u 'TDirectory' - 11 - directory", "Directories cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TDirectory' - 11 - -", "Directorise cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("TDirectory",1033,G__G__Base1_8_0_9, 105, G__get_linked_tagnum(&G__G__Base1LN_TDirectory), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDirectory",1033,G__G__Base1_8_0_10, 105, G__get_linked_tagnum(&G__G__Base1LN_TDirectory), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - 'Option_t' 10 '\"\"' option U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDirectory",1214,G__G__Base1_8_0_11, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' add", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TDirectory::AddDirectory) ), 0);
   G__memfunc_setup("AddDirectoryStatus",1858,G__G__Base1_8_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TDirectory::AddDirectoryStatus) ), 0);
   G__memfunc_setup("Append",600,G__G__Base1_8_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' replace", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Base1_8_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' replace", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AppendKey",897,G__G__Base1_8_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TKey' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Build",496,G__G__Base1_8_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 '0' motherFile U 'TDirectory' - 0 '0' motherDir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneObject",1096,G__G__Base1_8_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj g - 'Bool_t' 0 'kTRUE' autoadd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Close",502,G__G__Base1_8_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("cd",199,G__G__Base1_8_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '0' path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteAll",876,G__G__Base1_8_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' namecycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindKey",682,G__G__Base1_8_0_26, 85, G__get_linked_tagnum(&G__G__Base1LN_TKey), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindKeyAny",978,G__G__Base1_8_0_27, 85, G__get_linked_tagnum(&G__G__Base1LN_TKey), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObjectAny",1280,G__G__Base1_8_0_30, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObjectAnyFile",1664,G__G__Base1_8_0_31, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Get",288,G__G__Base1_8_0_32, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - namecycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirectory",1237,G__G__Base1_8_0_33, 85, G__get_linked_tagnum(&G__G__Base1LN_TDirectory), -1, 0, 3, 1, 1, 0, 
"C - - 10 - namecycle g - 'Bool_t' 0 'false' printError "
"C - - 10 '\"GetDirectory\"' funcname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectChecked",1566,G__G__Base1_8_0_34, 89, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - namecycle C - - 10 - classname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectChecked",1566,G__G__Base1_8_0_35, 89, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - namecycle U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectUnchecked",1793,G__G__Base1_8_0_36, 89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - namecycle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBufferSize",1301,G__G__Base1_8_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFile",672,G__G__Base1_8_0_38, 85, G__get_linked_tagnum(&G__G__Base1LN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKey",585,G__G__Base1_8_0_39, 85, G__get_linked_tagnum(&G__G__Base1LN_TKey), -1, 0, 2, 1, 1, 8, 
"C - - 10 - - s - 'Short_t' 0 '9999' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetList",700,G__G__Base1_8_0_40, 85, G__get_linked_tagnum(&G__G__Base1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfKeys",1293,G__G__Base1_8_0_41, 85, G__get_linked_tagnum(&G__G__Base1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMother",911,G__G__Base1_8_0_42, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMotherDir",1198,G__G__Base1_8_0_43, 85, G__get_linked_tagnum(&G__G__Base1LN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbytesKeys",1329,G__G__Base1_8_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNkeys",810,G__G__Base1_8_0_45, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekDir",967,G__G__Base1_8_0_46, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekParent",1298,G__G__Base1_8_0_47, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeekKeys",1092,G__G__Base1_8_0_48, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPathStatic",1301,G__G__Base1_8_0_49, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPath",685,G__G__Base1_8_0_50, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUUID",599,G__G__Base1_8_0_51, 117, G__get_linked_tagnum(&G__G__Base1LN_TUUID), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsModified",989,G__G__Base1_8_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsWritable",1014,G__G__Base1_8_0_54, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("mkdir",535,G__G__Base1_8_0_56, 85, G__get_linked_tagnum(&G__G__Base1LN_TDirectory), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenFile",786,G__G__Base1_8_0_57, 85, G__get_linked_tagnum(&G__G__Base1LN_TFile), -1, 0, 5, 1, 1, 0, 
"C - - 10 - - C - 'Option_t' 10 '\"\"' - "
"C - - 10 '\"\"' - i - 'Int_t' 0 '1' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Purge",515,G__G__Base1_8_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("pwd",331,G__G__Base1_8_0_61, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadAll",661,G__G__Base1_8_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadKeys",792,G__G__Base1_8_0_63, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTObject",1063,G__G__Base1_8_0_64, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Base1_8_0_65, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("rmdir",542,G__G__Base1_8_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Save",399,G__G__Base1_8_0_68, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveObjectAs",1178,G__G__Base1_8_0_69, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"U 'TObject' - 10 - - C - - 10 '\"\"' - "
"C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveSelf",793,G__G__Base1_8_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBufferSize",1313,G__G__Base1_8_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModified",1101,G__G__Base1_8_0_72, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMother",923,G__G__Base1_8_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - mother", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTRefAction",1275,G__G__Base1_8_0_75, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSeekDir",979,G__G__Base1_8_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWritable",1126,G__G__Base1_8_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"C - - 10 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTObject",1206,G__G__Base1_8_0_81, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TObject' - 10 - obj C - - 10 '0' name "
"C - 'Option_t' 10 '\"\"' - i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteObjectAny",1418,G__G__Base1_8_0_82, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 10 - - C - - 10 - - "
"C - - 10 - - C - 'Option_t' 10 '\"\"' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteObjectAny",1418,G__G__Base1_8_0_83, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 10 - - U 'TClass' - 10 - - "
"C - - 10 - - C - 'Option_t' 10 '\"\"' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteDirHeader",1395,G__G__Base1_8_0_84, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteKeys",935,G__G__Base1_8_0_85, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cd",167,G__G__Base1_8_0_86, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "C - - 10 - path", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*))(&TDirectory::Cd) ), 0);
   G__memfunc_setup("DecodeNameCycle",1461,G__G__Base1_8_0_87, 121, -1, -1, 0, 3, 3, 1, 0, 
"C - - 10 - namecycle C - - 0 - name "
"s - 'Short_t' 1 - cycle", (char*)NULL, (void*) G__func2void( (void (*)(const char*, char*, Short_t&))(&TDirectory::DecodeNameCycle) ), 0);
   G__memfunc_setup("EncodeNameCycle",1471,G__G__Base1_8_0_88, 121, -1, -1, 0, 3, 3, 1, 0, 
"C - - 0 - buffer C - - 10 - name "
"s - 'Short_t' 0 - cycle", (char*)NULL, (void*) G__func2void( (void (*)(char*, const char*, Short_t))(&TDirectory::EncodeNameCycle) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_8_0_89, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDirectory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_8_0_90, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDirectory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_8_0_91, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDirectory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_8_0_92, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDirectory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_8_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_8_0_97, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDirectory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_8_0_98, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDirectory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_8_0_99, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDirectory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_8_0_100, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDirectory::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDirectory", 1159, G__G__Base1_8_0_101, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootIOCtor(void) {
   /* TRootIOCtor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TRootIOCtor));
   // automatic default constructor
   G__memfunc_setup("TRootIOCtor", 1064, G__G__Base1_12_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TRootIOCtor), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TRootIOCtor", 1064, G__G__Base1_12_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TRootIOCtor), -1, 0, 1, 1, 1, 0, "u 'TRootIOCtor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRootIOCtor", 1190, G__G__Base1_12_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_12_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TRootIOCtor), -1, 1, 1, 1, 1, 0, "u 'TRootIOCtor' - 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__Base1LN_ROOT));
   G__memfunc_setup("CreateClass",1098,G__G__Base1_19_0_1, 85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_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__Base1_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__Base1_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__Base1_19_0_5, 85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_19_0_6, 85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_19_0_7, 85, G__get_linked_tagnum(&G__G__Base1LN_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__memfunc_setup("DefineBehavior",1403,G__G__Base1_19_0_8, 85, G__get_linked_tagnum(&G__G__Base1LN_ROOTcLcLTQObjectInitBehavior), -1, 0, 2, 1, 1, 1, 
"U 'TQObject' - 0 - - U 'TQObject' - 0 - -", (char*)NULL, (void*) G__func2void( (const ROOT::TQObjectInitBehavior* (*)(TQObject*, TQObject*))(&ROOT::DefineBehavior) ), 0);
   G__memfunc_setup("GetROOT",612,G__G__Base1_19_0_9, 85, G__get_linked_tagnum(&G__G__Base1LN_TROOT), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (TROOT* (*)())(&ROOT::GetROOT) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBrowser(void) {
   /* TBrowser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TBrowser));
   G__memfunc_setup("TBrowser",824,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 1, 1, 4, 0, "u 'TBrowser' - 11 - -", "TBrowser can not be copied since we do not know the type of the TBrowserImp (and it can not be 'Cloned')", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 1, 1, 1, 4, 0, "u 'TBrowser' - 11 - -", "TBrowser can not be copied since we do not know the type of the TBrowserImp (and it can not be 'Cloned')", (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 4, 1, 1, 0, 
"C - - 10 '\"Browser\"' name C - - 10 '\"ROOT Object Browser\"' title "
"U 'TBrowserImp' - 0 '0' extimp C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_4, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"U 'TBrowserImp' - 0 '0' extimp C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_5, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"U 'TBrowserImp' - 0 '0' extimp C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_6, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'TObject' - 0 - obj "
"C - - 10 '\"ROOT Object Browser\"' title C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_7, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name U 'TObject' - 0 - obj "
"C - - 10 - title h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_8, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name U 'TObject' - 0 - obj "
"C - - 10 - title i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_9, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name Y - - 0 - obj "
"U 'TClass' - 0 - cl C - - 10 '\"\"' objname "
"C - - 10 '\"ROOT Foreign Browser\"' title C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_10, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name Y - - 0 - obj "
"U 'TClass' - 0 - cl C - - 10 - objname "
"C - - 10 - title h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowser",824,G__G__Base1_77_0_11, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 10, 1, 1, 0, 
"C - - 10 - name Y - - 0 - obj "
"U 'TClass' - 0 - cl C - - 10 - objname "
"C - - 10 - title i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Base1_77_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 '0' name "
"i - 'Int_t' 0 '-1' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Base1_77_0_13, 121, -1, -1, 0, 4, 1, 1, 0, 
"Y - - 0 - obj U 'TClass' - 0 - cl "
"C - - 10 '0' name i - 'Int_t' 0 '-1' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCheckBox",1040,G__G__Base1_77_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckObjectItem",1476,G__G__Base1_77_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveCheckBox",1397,G__G__Base1_77_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Create",596,G__G__Base1_77_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", "Create this Browser", (void*) NULL, 1);
   G__memfunc_setup("BrowseObject",1225,G__G__Base1_77_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteDefaultAction",2038,G__G__Base1_77_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBrowserImp",1322,G__G__Base1_77_0_20, 85, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBrowserImp",1334,G__G__Base1_77_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowserImp' - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContextMenu",1434,G__G__Base1_77_0_22, 85, G__get_linked_tagnum(&G__G__Base1LN_TContextMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRefreshFlag",1385,G__G__Base1_77_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelected",1097,G__G__Base1_77_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRefreshFlag",1397,G__G__Base1_77_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Iconify",721,G__G__Base1_77_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,G__G__Base1_77_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelected",1109,G__G__Base1_77_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - clickedObject", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Show",417,G__G__Base1_77_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDrawOption",1319,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecPlugin",1012,G__G__Base1_77_0_33, 108, -1, G__defined_typename("Long_t"), 0, 5, 1, 1, 0, 
"C - - 10 '0' name C - - 10 '0' fname "
"C - - 10 '0' cmd i - 'Int_t' 0 '1' pos "
"i - 'Int_t' 0 '-1' subpos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatusText",1365,G__G__Base1_77_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - txt i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartEmbedding",1421,G__G__Base1_77_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - pos i - 'Int_t' 0 - subpos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopEmbedding",1317,G__G__Base1_77_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base1_77_0_37, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBrowser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_77_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_77_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBrowser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_77_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBrowser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_77_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_77_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_77_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBrowser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_77_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_77_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBrowser::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBrowser", 950, G__G__Base1_77_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTApplicationImp(void) {
   /* TApplicationImp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp));
   G__memfunc_setup("TApplicationImp",1518,G__G__Base1_114_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TApplicationImp",1518,G__G__Base1_114_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp), -1, 0, 3, 1, 1, 0, 
"C - - 10 - appClassName I - - 0 - argc "
"C - - 2 - argv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplicationName",1525,G__G__Base1_114_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_114_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,G__G__Base1_114_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Iconify",721,G__G__Base1_114_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCmdThread",1064,G__G__Base1_114_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", "by default (for UNIX) ROOT is a single thread application", (void*) NULL, 1);
   G__memfunc_setup("Init",404,G__G__Base1_114_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Open",402,G__G__Base1_114_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Raise",500,G__G__Base1_114_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Lower",521,G__G__Base1_114_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecCommand",1092,G__G__Base1_114_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGWin32Command' - 0 - code g - 'Bool_t' 0 - synch", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_114_0_13, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TApplicationImp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_114_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationImp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_114_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TApplicationImp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_114_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplicationImp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_114_0_17, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_114_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_114_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_114_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__Base1_114_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationImp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_114_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationImp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_114_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationImp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_114_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationImp::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TApplicationImp", 1518, G__G__Base1_114_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp), -1, 0, 1, 1, 1, 0, "u 'TApplicationImp' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TApplicationImp", 1644, G__G__Base1_114_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_114_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp), -1, 1, 1, 1, 1, 0, "u 'TApplicationImp' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTApplication(void) {
   /* TApplication */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TApplication));
   G__memfunc_setup("TApplication",1224,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TApplication), -1, 0, 1, 1, 4, 0, "u 'TApplication' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TApplication), -1, 1, 1, 1, 4, 0, "u 'TApplication' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TApplication",1224,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TApplication), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessRemote",1355,(G__InterfaceMethod) NULL, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 2, 0, 
"C - - 10 - line I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Help",393,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - line", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadGraphicsLibs",1595,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBatch",864,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSignalHandler",1608,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TSignalHandler' - 0 - sh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseRemoteLine",1519,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 3, 2, 0, 
"C - - 10 - ln u 'TString' - 1 - hostdir "
"u 'TString' - 1 - user i - 'Int_t' 1 - dbg "
"u 'TString' - 1 - script", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Open",402,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Base1LN_TApplication), -1, 0, 3, 3, 2, 0, 
"C - - 10 - url i - 'Int_t' 0 - debug "
"C - - 10 - script", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "U 'TApplication' - 0 - app", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TApplication",1224,G__G__Base1_116_0_12, 105, G__get_linked_tagnum(&G__G__Base1LN_TApplication), -1, 0, 5, 1, 1, 0, 
"C - - 10 - appClassName I - 'Int_t' 0 - argc "
"C - - 2 - argv Y - - 0 '0' options "
"i - 'Int_t' 0 '0' numOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitializeGraphics",1859,G__G__Base1_116_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,G__G__Base1_116_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - argc C - - 2 - argv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSignalHandler",1596,G__G__Base1_116_0_15, 85, G__get_linked_tagnum(&G__G__Base1LN_TSignalHandler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEchoMode",1072,G__G__Base1_116_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleException",1531,G__G__Base1_116_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - sig", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleIdleTimer",1483,G__G__Base1_116_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("HandleTermInput",1524,G__G__Base1_116_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,G__G__Base1_116_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessLine",1127,G__G__Base1_116_0_21, 108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0, 
"C - - 10 - line g - 'Bool_t' 0 'kFALSE' sync "
"I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessFile",1119,G__G__Base1_116_0_22, 108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0, 
"C - - 10 - file I - 'Int_t' 0 '0' error "
"g - 'Bool_t' 0 'kFALSE' keep", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Run",309,G__G__Base1_116_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' retrn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIdleTimer",1195,G__G__Base1_116_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - idleTimeInSec C - - 10 - command", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveIdleTimer",1517,G__G__Base1_116_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIdleCommand",1373,G__G__Base1_116_0_26, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartIdleing",1226,G__G__Base1_116_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopIdleing",1122,G__G__Base1_116_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExitOnException",1542,G__G__Base1_116_0_29, 105, G__get_linked_tagnum(&G__G__Base1LN_TApplicationcLcLEExitOnException), -1, 0, 1, 1, 1, 0, "i 'TApplication::EExitOnException' - 0 'kExit' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplicationName",1525,G__G__Base1_116_0_30, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_116_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,G__G__Base1_116_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Iconify",721,G__G__Base1_116_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Open",402,G__G__Base1_116_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Raise",500,G__G__Base1_116_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Lower",521,G__G__Base1_116_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCmdThread",1064,G__G__Base1_116_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetApplicationImp",1722,G__G__Base1_116_0_38, 85, G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Argc",381,G__G__Base1_116_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Argv",400,G__G__Base1_116_0_41, 67, -1, -1, 2, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Argv",400,G__G__Base1_116_0_42, 67, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NoLogOpt",786,G__G__Base1_116_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NoLogoOpt",897,G__G__Base1_116_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("QuitOpt",726,G__G__Base1_116_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InputFiles",1027,G__G__Base1_116_0_46, 85, G__get_linked_tagnum(&G__G__Base1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WorkingDirectory",1686,G__G__Base1_116_0_47, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearInputFiles",1514,G__G__Base1_116_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAppRemote",1197,G__G__Base1_116_0_49, 85, G__get_linked_tagnum(&G__G__Base1LN_TApplication), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRunning",925,G__G__Base1_116_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReturnFromRun",1353,G__G__Base1_116_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReturnFromRun",1653,G__G__Base1_116_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ret", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LineProcessed",1328,G__G__Base1_116_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - line", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Terminate",937,G__G__Base1_116_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' status", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("KeyPressed",1023,G__G__Base1_116_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - key", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,G__G__Base1_116_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - text", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteFile",1107,G__G__Base1_116_0_57, 108, -1, G__defined_typename("Long_t"), 0, 3, 3, 1, 0, 
"C - - 10 - file I - 'Int_t' 0 '0' error "
"g - 'Bool_t' 0 'kFALSE' keep", (char*)NULL, (void*) G__func2void( (Long_t (*)(const char*, Int_t*, Bool_t))(&TApplication::ExecuteFile) ), 0);
   G__memfunc_setup("GetApplications",1543,G__G__Base1_116_0_58, 85, G__get_linked_tagnum(&G__G__Base1LN_TList), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TList* (*)())(&TApplication::GetApplications) ), 0);
   G__memfunc_setup("CreateApplication",1736,G__G__Base1_116_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplication::CreateApplication) ), 0);
   G__memfunc_setup("NeedGraphicsLibs",1591,G__G__Base1_116_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplication::NeedGraphicsLibs) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_116_0_61, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TApplication::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_116_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplication::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_116_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TApplication::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_116_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplication::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_116_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_116_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplication::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_116_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplication::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_116_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplication::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_116_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplication::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TApplication", 1350, G__G__Base1_116_0_73, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAtt3D(void) {
   /* TAtt3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAtt3D));
   G__memfunc_setup("TAtt3D",500,G__G__Base1_119_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAtt3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof3D",743,G__G__Base1_119_0_2, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_119_0_3, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAtt3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_119_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAtt3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_119_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAtt3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_119_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAtt3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_119_0_7, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_119_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_119_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_119_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__Base1_119_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAtt3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_119_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAtt3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_119_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAtt3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_119_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAtt3D::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAtt3D", 500, G__G__Base1_119_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAtt3D), -1, 0, 1, 1, 1, 0, "u 'TAtt3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAtt3D", 626, G__G__Base1_119_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__Base1_119_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAtt3D), -1, 1, 1, 1, 1, 0, "u 'TAtt3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttAxis(void) {
   /* TAttAxis */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttAxis));
   G__memfunc_setup("TAttAxis",786,G__G__Base1_120_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_120_0_2, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttAxis' - 1 - attaxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdivisions",1350,G__G__Base1_120_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisColor",1204,G__G__Base1_120_0_4, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelColor",1279,G__G__Base1_120_0_5, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelFont",1175,G__G__Base1_120_0_6, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelOffset",1383,G__G__Base1_120_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelSize",1179,G__G__Base1_120_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleOffset",1417,G__G__Base1_120_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleSize",1213,G__G__Base1_120_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTickLength",1293,G__G__Base1_120_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleColor",1313,G__G__Base1_120_0_12, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleFont",1209,G__G__Base1_120_0_13, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttAxis",1217,G__G__Base1_120_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveAttributes",1462,G__G__Base1_120_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"C - - 10 - subname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNdivisions",1362,G__G__Base1_120_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '510' n g - 'Bool_t' 0 'kTRUE' optim", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNdivisions",1362,G__G__Base1_120_0_17, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n1 i - 'Int_t' 0 - n2 "
"i - 'Int_t' 0 - n3 g - 'Bool_t' 0 'kTRUE' optim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAxisColor",1216,G__G__Base1_120_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetLabelColor",1291,G__G__Base1_120_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetLabelFont",1187,G__G__Base1_120_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '62' font", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetLabelOffset",1395,G__G__Base1_120_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.005' offset", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetLabelSize",1191,G__G__Base1_120_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.04' size", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTickLength",1305,G__G__Base1_120_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.03' length", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTitleOffset",1429,G__G__Base1_120_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' offset", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTitleSize",1225,G__G__Base1_120_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.04' size", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTitleColor",1325,G__G__Base1_120_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTitleFont",1221,G__G__Base1_120_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '62' font", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_120_0_28, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttAxis::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_120_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttAxis::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_120_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttAxis::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_120_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttAxis::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_120_0_32, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_120_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_120_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_120_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_120_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttAxis::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_120_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttAxis::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_120_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttAxis::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_120_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttAxis::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttAxis", 786, G__G__Base1_120_0_40, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAttAxis), -1, 0, 1, 1, 1, 0, "u 'TAttAxis' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttAxis", 912, G__G__Base1_120_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_120_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAttAxis), -1, 1, 1, 1, 1, 0, "u 'TAttAxis' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttBBox(void) {
   /* TAttBBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttBBox));
   G__memfunc_setup("BBoxInit",767,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "f - 'Float_t' 0 '1e6' infinity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BBoxZero",779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"f - 'Float_t' 0 '0' epsilon f - 'Float_t' 0 '0' x "
"f - 'Float_t' 0 '0' y f - 'Float_t' 0 '0' z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BBoxClear",850,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BBoxCheckPoint",1363,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BBoxCheckPoint",1363,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "F - 'Float_t' 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertBBoxExtents",1736,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "f - 'Float_t' 0 '0.005' epsilon", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base1_121_0_9, 117, G__get_linked_tagnum(&G__G__Base1LN_TAttBBox), -1, 1, 1, 1, 1, 0, "u 'TAttBBox' - 11 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBBoxOK",805,G__G__Base1_121_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBBox",651,G__G__Base1_121_0_11, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertBBox",989,G__G__Base1_121_0_12, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetBBox",878,G__G__Base1_121_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,G__G__Base1_121_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Base1_121_0_15, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttBBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_121_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttBBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_121_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttBBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_121_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttBBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_121_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_121_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_121_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_121_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__Base1_121_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttBBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_121_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttBBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_121_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttBBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_121_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttBBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAttBBox", 870, G__G__Base1_121_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttFill(void) {
   /* TAttFill */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttFill));
   G__memfunc_setup("TAttFill",772,G__G__Base1_122_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttFill), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAttFill",772,G__G__Base1_122_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttFill), -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - fcolor s - 'Style_t' 0 - fstyle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_122_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttFill' - 1 - attfill", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFillColor",1190,G__G__Base1_122_0_4, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFillStyle",1208,G__G__Base1_122_0_5, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsTransparent",1358,G__G__Base1_122_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Modify",616,G__G__Base1_122_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttFill",1203,G__G__Base1_122_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveFillAttributes",1853,G__G__Base1_122_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"i - 'Int_t' 0 '1' coldef i - 'Int_t' 0 '1001' stydef", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillAttributes",1754,G__G__Base1_122_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetFillColor",1202,G__G__Base1_122_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - fcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillStyle",1220,G__G__Base1_122_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - fstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_122_0_13, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttFill::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_122_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFill::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_122_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttFill::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_122_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttFill::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_122_0_17, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_122_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_122_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_122_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__Base1_122_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFill::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_122_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttFill::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_122_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFill::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_122_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttFill::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttFill", 772, G__G__Base1_122_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAttFill), -1, 0, 1, 1, 1, 0, "u 'TAttFill' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttFill", 898, G__G__Base1_122_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_122_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAttFill), -1, 1, 1, 1, 1, 0, "u 'TAttFill' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttLine(void) {
   /* TAttLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttLine));
   G__memfunc_setup("TAttLine",773,G__G__Base1_123_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttLine), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAttLine",773,G__G__Base1_123_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttLine), -1, 0, 3, 1, 1, 0, 
"s - 'Color_t' 0 - lcolor s - 'Style_t' 0 - lstyle "
"s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_123_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttLine' - 1 - attline", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoLine",1430,G__G__Base1_123_0_4, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py "
"d - 'Double_t' 0 - xp1 d - 'Double_t' 0 - yp1 "
"d - 'Double_t' 0 - xp2 d - 'Double_t' 0 - yp2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineColor",1191,G__G__Base1_123_0_5, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineStyle",1209,G__G__Base1_123_0_6, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineWidth",1192,G__G__Base1_123_0_7, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Modify",616,G__G__Base1_123_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttLine",1204,G__G__Base1_123_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveLineAttributes",1854,G__G__Base1_123_0_10, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"i - 'Int_t' 0 '1' coldef i - 'Int_t' 0 '1' stydef "
"i - 'Int_t' 0 '1' widdef", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineAttributes",1755,G__G__Base1_123_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,G__G__Base1_123_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - lcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,G__G__Base1_123_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - lstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,G__G__Base1_123_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_123_0_15, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_123_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_123_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_123_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_123_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_123_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_123_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_123_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__Base1_123_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_123_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_123_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_123_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttLine::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttLine", 773, G__G__Base1_123_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAttLine), -1, 0, 1, 1, 1, 0, "u 'TAttLine' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttLine", 899, G__G__Base1_123_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_123_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAttLine), -1, 1, 1, 1, 1, 0, "u 'TAttLine' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttMarker(void) {
   /* TAttMarker */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttMarker));
   G__memfunc_setup("TAttMarker",991,G__G__Base1_125_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttMarker), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAttMarker",991,G__G__Base1_125_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttMarker), -1, 0, 3, 1, 1, 0, 
"s - 'Color_t' 0 - color s - 'Style_t' 0 - style "
"f - 'Size_t' 0 - msize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_125_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttMarker' - 1 - attmarker", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarkerColor",1409,G__G__Base1_125_0_4, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMarkerStyle",1427,G__G__Base1_125_0_5, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMarkerSize",1309,G__G__Base1_125_0_6, 102, -1, G__defined_typename("Size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Modify",616,G__G__Base1_125_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttMarker",1422,G__G__Base1_125_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' toption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveMarkerAttributes",2072,G__G__Base1_125_0_9, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"i - 'Int_t' 0 '1' coldef i - 'Int_t' 0 '1' stydef "
"i - 'Int_t' 0 '1' sizdef", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerAttributes",1973,G__G__Base1_125_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMarkerColor",1421,G__G__Base1_125_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' tcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerStyle",1439,G__G__Base1_125_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '1' mstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerSize",1321,G__G__Base1_125_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Size_t' 0 '1' msize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_125_0_14, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttMarker::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_125_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarker::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_125_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttMarker::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_125_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttMarker::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_125_0_18, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_125_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_125_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_125_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_125_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarker::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_125_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttMarker::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_125_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarker::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_125_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttMarker::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttMarker", 991, G__G__Base1_125_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAttMarker), -1, 0, 1, 1, 1, 0, "u 'TAttMarker' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttMarker", 1117, G__G__Base1_125_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_125_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAttMarker), -1, 1, 1, 1, 1, 0, "u 'TAttMarker' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttPad(void) {
   /* TAttPad */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttPad));
   G__memfunc_setup("TAttPad",658,G__G__Base1_127_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_127_0_2, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttPad' - 1 - attpad", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBottomMargin",1523,G__G__Base1_127_0_3, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftMargin",1289,G__G__Base1_127_0_4, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightMargin",1404,G__G__Base1_127_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopMargin",1201,G__G__Base1_127_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAfile",769,G__G__Base1_127_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXfile",792,G__G__Base1_127_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYfile",793,G__G__Base1_127_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAstat",797,G__G__Base1_127_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXstat",820,G__G__Base1_127_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYstat",821,G__G__Base1_127_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFillColor",1681,G__G__Base1_127_0_13, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameLineColor",1682,G__G__Base1_127_0_14, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFillStyle",1699,G__G__Base1_127_0_15, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameLineStyle",1700,G__G__Base1_127_0_16, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameLineWidth",1683,G__G__Base1_127_0_17, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBorderSize",1796,G__G__Base1_127_0_18, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBorderMode",1774,G__G__Base1_127_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Base1_127_0_20, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttPad",1089,G__G__Base1_127_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBottomMargin",1535,G__G__Base1_127_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - bottommargin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeftMargin",1301,G__G__Base1_127_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - leftmargin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRightMargin",1416,G__G__Base1_127_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - rightmargin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTopMargin",1213,G__G__Base1_127_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - topmargin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMargin",906,G__G__Base1_127_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - left f - 'Float_t' 0 - right "
"f - 'Float_t' 0 - bottom f - 'Float_t' 0 - top", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAfile",781,G__G__Base1_127_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - afile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetXfile",804,G__G__Base1_127_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - xfile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetYfile",805,G__G__Base1_127_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - yfile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAstat",809,G__G__Base1_127_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - astat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetXstat",832,G__G__Base1_127_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - xstat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetYstat",833,G__G__Base1_127_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - ystat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFrameFillColor",1693,G__G__Base1_127_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLineColor",1694,G__G__Base1_127_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameFillStyle",1711,G__G__Base1_127_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' styl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLineStyle",1712,G__G__Base1_127_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' styl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLineWidth",1695,G__G__Base1_127_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameBorderSize",1808,G__G__Base1_127_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameBorderMode",1786,G__G__Base1_127_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base1_127_0_40, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttPad::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_127_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttPad::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_127_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttPad::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_127_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttPad::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_127_0_44, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_127_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_127_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_127_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_127_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttPad::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_127_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttPad::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_127_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttPad::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_127_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttPad::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttPad", 658, G__G__Base1_127_0_52, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAttPad), -1, 0, 1, 1, 1, 0, "u 'TAttPad' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttPad", 784, G__G__Base1_127_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_127_0_54, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAttPad), -1, 1, 1, 1, 1, 0, "u 'TAttPad' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttText(void) {
   /* TAttText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TAttText));
   G__memfunc_setup("TAttText",802,G__G__Base1_128_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAttText",802,G__G__Base1_128_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TAttText), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - align f - 'Float_t' 0 - angle "
"s - 'Color_t' 0 - color s - 'Style_t' 0 - font "
"f - 'Float_t' 0 - tsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_128_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttText' - 1 - atttext", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextAlign",1200,G__G__Base1_128_0_4, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextAngle",1196,G__G__Base1_128_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextColor",1220,G__G__Base1_128_0_6, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextFont",1116,G__G__Base1_128_0_7, 115, -1, G__defined_typename("Font_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextSize",1120,G__G__Base1_128_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Modify",616,G__G__Base1_128_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttText",1233,G__G__Base1_128_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' toption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveTextAttributes",1883,G__G__Base1_128_0_11, 121, -1, -1, 0, 7, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"i - 'Int_t' 0 '12' alidef f - 'Float_t' 0 '0' angdef "
"i - 'Int_t' 0 '1' coldef i - 'Int_t' 0 '61' fondef "
"f - 'Float_t' 0 '1' sizdef", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextAttributes",1784,G__G__Base1_128_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTextAlign",1212,G__G__Base1_128_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 '11' align", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextAngle",1208,G__G__Base1_128_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' tangle", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Base1_128_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' tcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,G__G__Base1_128_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 '62' tfont", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextSize",1132,G__G__Base1_128_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' tsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextSizePixels",1761,G__G__Base1_128_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npixels", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_128_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_128_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_128_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_128_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_128_0_23, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_128_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_128_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_128_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__Base1_128_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_128_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_128_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_128_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttText::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttText", 802, G__G__Base1_128_0_31, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TAttText), -1, 0, 1, 1, 1, 0, "u 'TAttText' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttText", 928, G__G__Base1_128_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_128_0_33, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TAttText), -1, 1, 1, 1, 1, 0, "u 'TAttText' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBenchmark(void) {
   /* TBenchmark */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TBenchmark));
   G__memfunc_setup("TBenchmark",991,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TBenchmark), -1, 0, 1, 1, 2, 0, "u 'TBenchmark' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TBenchmark), -1, 1, 1, 1, 2, 0, "u 'TBenchmark' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBenchmark",991,G__G__Base1_131_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TBenchmark), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBench",768,G__G__Base1_131_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCpuTime",983,G__G__Base1_131_0_5, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRealTime",1075,G__G__Base1_131_0_6, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Base1_131_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_131_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Start",526,G__G__Base1_131_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stop",422,G__G__Base1_131_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Summary",750,G__G__Base1_131_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 1 - rt f - 'Float_t' 1 - cp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_131_0_13, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBenchmark::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_131_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBenchmark::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_131_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBenchmark::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_131_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBenchmark::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_131_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__Base1_131_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBenchmark::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_131_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBenchmark::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_131_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBenchmark::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_131_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBenchmark::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBenchmark", 1117, G__G__Base1_131_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBrowserImp(void) {
   /* TBrowserImp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp));
   G__memfunc_setup("TBrowserImp",1118,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 1, 1, 2, 0, "u 'TBrowserImp' - 11 - br", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 1, 1, 1, 2, 0, "u 'TBrowserImp' - 11 - br", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowserImp",1118,G__G__Base1_133_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 '0' b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowserImp",1118,G__G__Base1_133_0_4, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 5, 1, 1, 0, 
"U 'TBrowser' - 0 - b C - - 10 - title "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBrowserImp",1118,G__G__Base1_133_0_5, 105, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 7, 1, 1, 0, 
"U 'TBrowser' - 0 - b C - - 10 - title "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Base1_133_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - - C - - 10 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddCheckBox",1040,G__G__Base1_133_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckObjectItem",1476,G__G__Base1_133_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveCheckBox",1397,G__G__Base1_133_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BrowseObj",909,G__G__Base1_133_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browser",740,G__G__Base1_133_0_11, 85, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteDefaultAction",2038,G__G__Base1_133_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Iconify",721,G__G__Base1_133_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,G__G__Base1_133_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,G__G__Base1_133_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_133_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawOption",1331,G__G__Base1_133_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDrawOption",1319,G__G__Base1_133_0_18, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecPlugin",1012,G__G__Base1_133_0_19, 108, -1, G__defined_typename("Long_t"), 0, 5, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"C - - 10 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatusText",1365,G__G__Base1_133_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartEmbedding",1421,G__G__Base1_133_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopEmbedding",1317,G__G__Base1_133_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMainFrame",1168,G__G__Base1_133_0_23, 85, G__get_linked_tagnum(&G__G__Base1LN_TGMainFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBrowser",1028,G__G__Base1_133_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBrowser",1040,G__G__Base1_133_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_133_0_26, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBrowserImp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_133_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowserImp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_133_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBrowserImp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_133_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBrowserImp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_133_0_30, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_133_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_133_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_133_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_133_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowserImp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_133_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBrowserImp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_133_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowserImp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_133_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBrowserImp::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBrowserImp", 1244, G__G__Base1_133_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTContextMenu(void) {
   /* TContextMenu */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TContextMenu));
   G__memfunc_setup("TContextMenu",1230,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TContextMenu), -1, 0, 1, 1, 4, 0, "u 'TContextMenu' - 11 - -", "TContextMenu can not be copied since we do not know the actual type of the TContextMenuImp (and it can not be 'Cloned')", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TContextMenu), -1, 1, 1, 1, 4, 0, "u 'TContextMenu' - 11 - -", "TContextMenu can not be copied since we do not know the actual type of the TContextMenuImp (and it can not be 'Cloned')", (void*) NULL, 0);
   G__memfunc_setup("DisplayPopUp",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TContextMenu",1230,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TContextMenu), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TContextMenu",1230,G__G__Base1_134_0_5, 105, G__get_linked_tagnum(&G__G__Base1LN_TContextMenu), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"Context sensitive popup menu\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Action",606,G__G__Base1_134_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TMethod' - 0 - method", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Action",606,G__G__Base1_134_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TToggle' - 0 - toggle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Action",606,G__G__Base1_134_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClassMenuItem' - 0 - classmenuitem", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Action",606,G__G__Base1_134_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Action",606,G__G__Base1_134_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TToggle' - 0 - toggle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateArgumentTitle",1945,G__G__Base1_134_0_11, 67, -1, -1, 0, 1, 1, 1, 1, "U 'TMethodArg' - 0 - argument", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateDialogTitle",1702,G__G__Base1_134_0_12, 67, -1, -1, 0, 2, 1, 1, 1, 
"U 'TObject' - 0 - object U 'TFunction' - 0 - method", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePopupTitle",1642,G__G__Base1_134_0_13, 67, -1, -1, 0, 1, 1, 1, 1, "U 'TObject' - 0 - object", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Execute",723,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - method C - - 10 - params "
"I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Execute",723,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TMethod' - 0 - method U 'TObjArray' - 0 - params "
"I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Execute",723,G__G__Base1_134_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TFunction' - 0 - method "
"C - - 10 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Execute",723,G__G__Base1_134_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TFunction' - 0 - method "
"U 'TObjArray' - 0 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Execute",723,G__G__Base1_134_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Execute",723,G__G__Base1_134_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBrowser",1028,G__G__Base1_134_0_20, 85, G__get_linked_tagnum(&G__G__Base1LN_TBrowser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContextMenuImp",1728,G__G__Base1_134_0_21, 85, G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedCanvas",1701,G__G__Base1_134_0_22, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedMethod",1706,G__G__Base1_134_0_23, 85, G__get_linked_tagnum(&G__G__Base1LN_TFunction), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedObject",1696,G__G__Base1_134_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCalledObject",1468,G__G__Base1_134_0_25, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedMenuItem",1901,G__G__Base1_134_0_26, 85, G__get_linked_tagnum(&G__G__Base1LN_TClassMenuItem), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedPad",1374,G__G__Base1_134_0_27, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Popup",532,G__G__Base1_134_0_28, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"U 'TObject' - 0 - obj U 'TVirtualPad' - 0 '0' c "
"U 'TVirtualPad' - 0 '0' p", "Create menu from canvas", (void*) NULL, 1);
   G__memfunc_setup("Popup",532,G__G__Base1_134_0_29, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"U 'TObject' - 0 - obj U 'TBrowser' - 0 - b", "Create menu from Browser", (void*) NULL, 1);
   G__memfunc_setup("SetCanvas",904,G__G__Base1_134_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBrowser",1040,G__G__Base1_134_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMethod",909,G__G__Base1_134_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFunction' - 0 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCalledObject",1480,G__G__Base1_134_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelectedMenuItem",1913,G__G__Base1_134_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClassMenuItem' - 0 - mi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNameTitle",1199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Base1_134_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPad",577,G__G__Base1_134_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_134_0_38, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TContextMenu::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_134_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TContextMenu::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_134_0_40, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TContextMenu::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_134_0_41, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TContextMenu::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_134_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_134_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TContextMenu::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_134_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TContextMenu::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_134_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TContextMenu::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_134_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TContextMenu::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TContextMenu", 1356, G__G__Base1_134_0_50, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBuffer3D(void) {
   /* TBuffer3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBuffer3D",805,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D), -1, 0, 1, 1, 4, 0, "u 'TBuffer3D' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D), -1, 1, 1, 1, 4, 1, "u 'TBuffer3D' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCSLevel",942,G__G__Base1_137_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TBuffer3D::GetCSLevel) ), 0);
   G__memfunc_setup("IncCSLevel",936,G__G__Base1_137_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBuffer3D::IncCSLevel) ), 0);
   G__memfunc_setup("DecCSLevel",922,G__G__Base1_137_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TBuffer3D::DecCSLevel) ), 0);
   G__memfunc_setup("TBuffer3D",805,G__G__Base1_137_0_7, 105, G__get_linked_tagnum(&G__G__Base1LN_TBuffer3D), -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - type h - 'UInt_t' 0 '0' reqPnts "
"h - 'UInt_t' 0 '0' reqPntsCapacity h - 'UInt_t' 0 '0' reqSegs "
"h - 'UInt_t' 0 '0' reqSegsCapacity h - 'UInt_t' 0 '0' reqPols "
"h - 'UInt_t' 0 '0' reqPolsCapacity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSectionsValid",1636,G__G__Base1_137_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearSectionsValid",1823,G__G__Base1_137_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SectionsValid",1336,G__G__Base1_137_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSections",1128,G__G__Base1_137_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalMasterIdentity",2253,G__G__Base1_137_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "Set fLocalMaster in kCore to identity", (void*) NULL, 0);
   G__memfunc_setup("SetAABoundingBox",1549,G__G__Base1_137_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - origin D - 'Double_t' 10 - halfLengths", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRawSizes",1124,G__G__Base1_137_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - reqPnts h - 'UInt_t' 0 - reqPntsCapacity "
"h - 'UInt_t' 0 - reqSegs h - 'UInt_t' 0 - reqSegsCapacity "
"h - 'UInt_t' 0 - reqPols h - 'UInt_t' 0 - reqPolsCapacity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NbPnts",597,G__G__Base1_137_0_15, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NbSegs",578,G__G__Base1_137_0_16, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NbPols",590,G__G__Base1_137_0_17, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Type",418,G__G__Base1_137_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base1_137_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBuffer3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_137_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBuffer3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_137_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBuffer3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_137_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBuffer3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_137_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__Base1_137_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBuffer3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_137_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBuffer3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_137_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBuffer3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_137_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBuffer3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBuffer3D", 931, G__G__Base1_137_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCanvasImp(void) {
   /* TCanvasImp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp));
   G__memfunc_setup("TCanvasImp",982,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 1, 1, 2, 0, "u 'TCanvasImp' - 11 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 1, 1, 1, 2, 0, "u 'TCanvasImp' - 11 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lock",393,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unlock",620,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLocked",782,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TCanvasImp",982,G__G__Base1_147_0_6, 105, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 '0' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCanvasImp",982,G__G__Base1_147_0_7, 105, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 4, 1, 1, 0, 
"U 'TCanvas' - 0 - c C - - 10 - name "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCanvasImp",982,G__G__Base1_147_0_8, 105, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 6, 1, 1, 0, 
"U 'TCanvas' - 0 - c C - - 10 - name "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Canvas",604,G__G__Base1_147_0_9, 85, G__get_linked_tagnum(&G__G__Base1LN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,G__G__Base1_147_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForceUpdate",1106,G__G__Base1_147_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWindowGeometry",1764,G__G__Base1_147_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 1 - x i - 'Int_t' 1 - y "
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Iconify",721,G__G__Base1_147_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitWindow",1036,G__G__Base1_147_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatusText",1365,G__G__Base1_147_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' text i - 'Int_t' 0 '0' partidx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowPosition",1785,G__G__Base1_147_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowSize",1343,G__G__Base1_147_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowTitle",1446,G__G__Base1_147_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - newTitle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCanvasSize",1315,G__G__Base1_147_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_147_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMenuBar",1099,G__G__Base1_147_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowStatusBar",1338,G__G__Base1_147_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RaiseWindow",1132,G__G__Base1_147_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReallyDelete",1212,G__G__Base1_147_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowEditor",1032,G__G__Base1_147_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowToolBar",1108,G__G__Base1_147_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowToolTips",1247,G__G__Base1_147_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasEditor",899,G__G__Base1_147_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasMenuBar",966,G__G__Base1_147_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasStatusBar",1205,G__G__Base1_147_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasToolBar",975,G__G__Base1_147_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasToolTips",1114,G__G__Base1_147_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_147_0_33, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCanvasImp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_147_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCanvasImp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_147_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCanvasImp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_147_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCanvasImp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_147_0_37, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_147_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_147_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_147_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_147_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCanvasImp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_147_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCanvasImp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_147_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCanvasImp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_147_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCanvasImp::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCanvasImp", 1108, G__G__Base1_147_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTColor(void) {
   /* TColor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TColor));
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HLStoRGB1",726,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 3, 3, 4, 0, 
"f - 'Float_t' 0 - rn1 f - 'Float_t' 0 - rn2 "
"f - 'Float_t' 0 - huei", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TColor",595,G__G__Base1_150_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TColor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TColor",595,G__G__Base1_150_0_4, 105, G__get_linked_tagnum(&G__G__Base1LN_TColor), -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - color f - 'Float_t' 0 - r "
"f - 'Float_t' 0 - g f - 'Float_t' 0 - b "
"C - - 10 '\"\"' name f - 'Float_t' 0 '1' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TColor",595,G__G__Base1_150_0_5, 105, G__get_linked_tagnum(&G__G__Base1LN_TColor), -1, 0, 1, 1, 1, 0, "u 'TColor' - 11 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsHexString",1104,G__G__Base1_150_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateColorWheel",1608,G__G__Base1_150_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TColor::CreateColorWheel) ), 0);
   G__memfunc_setup("CreateColorsGray",1625,G__G__Base1_150_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TColor::CreateColorsGray) ), 0);
   G__memfunc_setup("CreateColorsCircle",1816,G__G__Base1_150_0_10, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - offset C - - 10 - name "
"B - 'UChar_t' 0 - rgb", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, const char*, UChar_t*))(&TColor::CreateColorsCircle) ), 0);
   G__memfunc_setup("CreateColorsRectangle",2139,G__G__Base1_150_0_11, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - offset C - - 10 - name "
"B - 'UChar_t' 0 - rgb", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, const char*, UChar_t*))(&TColor::CreateColorsRectangle) ), 0);
   G__memfunc_setup("CreateGradientColorTable",2409,G__G__Base1_150_0_12, 105, -1, G__defined_typename("Int_t"), 0, 6, 3, 1, 0, 
"h - 'UInt_t' 0 - Number D - 'Double_t' 0 - Stops "
"D - 'Double_t' 0 - Red D - 'Double_t' 0 - Green "
"D - 'Double_t' 0 - Blue h - 'UInt_t' 0 - NColors", (char*)NULL, (void*) G__func2void( (Int_t (*)(UInt_t, Double_t*, Double_t*, Double_t*, Double_t*, UInt_t))(&TColor::CreateGradientColorTable) ), 0);
   G__memfunc_setup("GetColorPalette",1518,G__G__Base1_150_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TColor::GetColorPalette) ), 0);
   G__memfunc_setup("GetNumberOfColors",1712,G__G__Base1_150_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TColor::GetNumberOfColors) ), 0);
   G__memfunc_setup("GetRGB",507,G__G__Base1_150_0_15, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'Float_t' 1 - r f - 'Float_t' 1 - g "
"f - 'Float_t' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHLS",519,G__G__Base1_150_0_16, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'Float_t' 1 - h f - 'Float_t' 1 - l "
"f - 'Float_t' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumber",905,G__G__Base1_150_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPixel",802,G__G__Base1_150_0_18, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRed",571,G__G__Base1_150_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGreen",785,G__G__Base1_150_0_20, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlue",680,G__G__Base1_150_0_21, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHue",578,G__G__Base1_150_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLight",792,G__G__Base1_150_0_23, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSaturation",1354,G__G__Base1_150_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha",774,G__G__Base1_150_0_25, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGrayscale",1211,G__G__Base1_150_0_26, 102, -1, G__defined_typename("Float_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("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRGB",519,G__G__Base1_150_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitializeColors",1668,G__G__Base1_150_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TColor::InitializeColors) ), 0);
   G__memfunc_setup("HLS2RGB",500,G__G__Base1_150_0_31, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - h f - 'Float_t' 0 - l "
"f - 'Float_t' 0 - s f - 'Float_t' 1 - r "
"f - 'Float_t' 1 - g f - 'Float_t' 1 - b", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t&, Float_t&, Float_t&))(&TColor::HLS2RGB) ), 0);
   G__memfunc_setup("HLS2RGB",500,G__G__Base1_150_0_32, 121, -1, -1, 0, 6, 3, 1, 0, 
"i - 'Int_t' 0 - h i - 'Int_t' 0 - l "
"i - 'Int_t' 0 - s i - 'Int_t' 1 - r "
"i - 'Int_t' 1 - g i - 'Int_t' 1 - b", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Int_t, Int_t&, Int_t&, Int_t&))(&TColor::HLS2RGB) ), 0);
   G__memfunc_setup("HLStoRGB",677,G__G__Base1_150_0_33, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - h f - 'Float_t' 0 - l "
"f - 'Float_t' 0 - s f - 'Float_t' 1 - r "
"f - 'Float_t' 1 - g f - 'Float_t' 1 - b", "backward compatible", (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t&, Float_t&, Float_t&))(&TColor::HLStoRGB) ), 0);
   G__memfunc_setup("HSV2RGB",510,G__G__Base1_150_0_34, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - h f - 'Float_t' 0 - s "
"f - 'Float_t' 0 - v f - 'Float_t' 1 - r "
"f - 'Float_t' 1 - g f - 'Float_t' 1 - b", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t&, Float_t&, Float_t&))(&TColor::HSV2RGB) ), 0);
   G__memfunc_setup("RGB2HLS",500,G__G__Base1_150_0_35, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b f - 'Float_t' 1 - h "
"f - 'Float_t' 1 - l f - 'Float_t' 1 - s", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t&, Float_t&, Float_t&))(&TColor::RGB2HLS) ), 0);
   G__memfunc_setup("RGB2HLS",500,G__G__Base1_150_0_36, 121, -1, -1, 0, 6, 3, 1, 0, 
"i - 'Int_t' 0 - r i - 'Int_t' 0 - g "
"i - 'Int_t' 0 - b i - 'Int_t' 1 - h "
"i - 'Int_t' 1 - l i - 'Int_t' 1 - s", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Int_t, Int_t&, Int_t&, Int_t&))(&TColor::RGB2HLS) ), 0);
   G__memfunc_setup("RGBtoHLS",677,G__G__Base1_150_0_37, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b f - 'Float_t' 1 - h "
"f - 'Float_t' 1 - l f - 'Float_t' 1 - s", "backward compatible", (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t&, Float_t&, Float_t&))(&TColor::RGBtoHLS) ), 0);
   G__memfunc_setup("RGB2HSV",510,G__G__Base1_150_0_38, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b f - 'Float_t' 1 - h "
"f - 'Float_t' 1 - s f - 'Float_t' 1 - v", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t&, Float_t&, Float_t&))(&TColor::RGB2HSV) ), 0);
   G__memfunc_setup("GetColor",799,G__G__Base1_150_0_39, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "C - - 10 - hexcolor", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*))(&TColor::GetColor) ), 0);
   G__memfunc_setup("GetColor",799,G__G__Base1_150_0_40, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b", (char*)NULL, (void*) G__func2void( (Int_t (*)(Float_t, Float_t, Float_t))(&TColor::GetColor) ), 0);
   G__memfunc_setup("GetColor",799,G__G__Base1_150_0_41, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - r i - 'Int_t' 0 - g "
"i - 'Int_t' 0 - b", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t, Int_t, Int_t))(&TColor::GetColor) ), 0);
   G__memfunc_setup("GetColor",799,G__G__Base1_150_0_42, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "k - 'ULong_t' 0 - pixel", (char*)NULL, (void*) G__func2void( (Int_t (*)(ULong_t))(&TColor::GetColor) ), 0);
   G__memfunc_setup("GetColorBright",1407,G__G__Base1_150_0_43, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - color", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TColor::GetColorBright) ), 0);
   G__memfunc_setup("GetColorDark",1185,G__G__Base1_150_0_44, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - color", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TColor::GetColorDark) ), 0);
   G__memfunc_setup("Number2Pixel",1181,G__G__Base1_150_0_45, 107, -1, G__defined_typename("ULong_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - ci", (char*)NULL, (void*) G__func2void( (ULong_t (*)(Int_t))(&TColor::Number2Pixel) ), 0);
   G__memfunc_setup("RGB2Pixel",783,G__G__Base1_150_0_46, 107, -1, G__defined_typename("ULong_t"), 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - r i - 'Int_t' 0 - g "
"i - 'Int_t' 0 - b", (char*)NULL, (void*) G__func2void( (ULong_t (*)(Int_t, Int_t, Int_t))(&TColor::RGB2Pixel) ), 0);
   G__memfunc_setup("RGB2Pixel",783,G__G__Base1_150_0_47, 107, -1, G__defined_typename("ULong_t"), 0, 3, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b", (char*)NULL, (void*) G__func2void( (ULong_t (*)(Float_t, Float_t, Float_t))(&TColor::RGB2Pixel) ), 0);
   G__memfunc_setup("Pixel2RGB",783,G__G__Base1_150_0_48, 121, -1, -1, 0, 4, 3, 1, 0, 
"k - 'ULong_t' 0 - pixel i - 'Int_t' 1 - r "
"i - 'Int_t' 1 - g i - 'Int_t' 1 - b", (char*)NULL, (void*) G__func2void( (void (*)(ULong_t, Int_t&, Int_t&, Int_t&))(&TColor::Pixel2RGB) ), 0);
   G__memfunc_setup("Pixel2RGB",783,G__G__Base1_150_0_49, 121, -1, -1, 0, 4, 3, 1, 0, 
"k - 'ULong_t' 0 - pixel f - 'Float_t' 1 - r "
"f - 'Float_t' 1 - g f - 'Float_t' 1 - b", (char*)NULL, (void*) G__func2void( (void (*)(ULong_t, Float_t&, Float_t&, Float_t&))(&TColor::Pixel2RGB) ), 0);
   G__memfunc_setup("PixelAsHexString",1618,G__G__Base1_150_0_50, 67, -1, -1, 0, 1, 3, 1, 1, "k - 'ULong_t' 0 - pixel", (char*)NULL, (void*) G__func2void( (const char* (*)(ULong_t))(&TColor::PixelAsHexString) ), 0);
   G__memfunc_setup("SaveColor",910,G__G__Base1_150_0_51, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out i - 'Int_t' 0 - ci", (char*)NULL, (void*) G__func2void( (void (*)(ostream&, Int_t))(&TColor::SaveColor) ), 0);
   G__memfunc_setup("IsGrayscale",1111,G__G__Base1_150_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TColor::IsGrayscale) ), 0);
   G__memfunc_setup("SetGrayscale",1223,G__G__Base1_150_0_53, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' set", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TColor::SetGrayscale) ), 0);
   G__memfunc_setup("SetPalette",1019,G__G__Base1_150_0_54, 121, -1, -1, 0, 2, 3, 1, 0, 
"i - 'Int_t' 0 - ncolors I - 'Int_t' 0 - colors", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t*))(&TColor::SetPalette) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_150_0_55, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TColor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_150_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TColor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_150_0_57, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TColor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_150_0_58, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TColor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_150_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_150_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TColor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_150_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TColor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_150_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TColor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_150_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TColor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TColor", 721, G__G__Base1_150_0_67, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_150_0_68, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TColor), -1, 1, 1, 1, 1, 0, "u 'TColor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTContextMenuImp(void) {
   /* TContextMenuImp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp));
   G__memfunc_setup("TContextMenuImp",1524,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp), -1, 0, 1, 1, 2, 0, "u 'TContextMenuImp' - 11 - cmi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp), -1, 1, 1, 1, 2, 0, "u 'TContextMenuImp' - 11 - cmi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TContextMenuImp",1524,G__G__Base1_152_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp), -1, 0, 1, 1, 1, 0, "U 'TContextMenu' - 0 '0' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContextMenu",1434,G__G__Base1_152_0_4, 85, G__get_linked_tagnum(&G__G__Base1LN_TContextMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dialog",592,G__G__Base1_152_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TFunction' - 0 - function", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dialog",592,G__G__Base1_152_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TMethod' - 0 - method", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisplayPopup",1258,G__G__Base1_152_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_152_0_8, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TContextMenuImp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_152_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TContextMenuImp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_152_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TContextMenuImp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_152_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TContextMenuImp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_152_0_12, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_152_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_152_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_152_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__Base1_152_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TContextMenuImp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_152_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TContextMenuImp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_152_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TContextMenuImp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_152_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TContextMenuImp::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TContextMenuImp", 1650, G__G__Base1_152_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualPad(void) {
   /* TVirtualPad */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad));
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 2, 0, "", "used to set gTQSender", (void*) NULL, 1);
   G__memfunc_setup("AbsCoordinates",1425,G__G__Base1_154_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AbsPixeltoX",1107,G__G__Base1_154_0_5, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - px", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AbsPixeltoY",1108,G__G__Base1_154_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddExec",654,G__G__Base1_154_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - command", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("cd",199,G__G__Base1_154_0_8, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' subpadnumber", (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 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Close",502,G__G__Base1_154_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CopyPixmap",1034,G__G__Base1_154_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CopyPixmaps",1149,G__G__Base1_154_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeleteExec",984,G__G__Base1_154_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Divide",597,G__G__Base1_154_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 '1' nx i - 'Int_t' 0 '1' ny "
"f - 'Float_t' 0 '0.01' xmargin f - 'Float_t' 0 '0.01' ymargin "
"i - 'Int_t' 0 '0' color", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawClassObject",1499,G__G__Base1_154_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawFrame",889,G__G__Base1_154_0_17, 85, G__get_linked_tagnum(&G__G__Base1LN_TH1F), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax "
"C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExecuteEventAxis",1642,G__G__Base1_154_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py U 'TAxis' - 0 - axis", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBorderMode",1283,G__G__Base1_154_0_19, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBorderSize",1305,G__G__Base1_154_0_20, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCanvasID",1033,G__G__Base1_154_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCanvasImp",1186,G__G__Base1_154_0_22, 85, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCanvas",892,G__G__Base1_154_0_23, 85, G__get_linked_tagnum(&G__G__Base1LN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVirtCanvas",1313,G__G__Base1_154_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEvent",802,G__G__Base1_154_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEventX",890,G__G__Base1_154_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEventY",891,G__G__Base1_154_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFrame",779,G__G__Base1_154_0_28, 85, G__get_linked_tagnum(&G__G__Base1LN_TFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetHighLightColor",1687,G__G__Base1_154_0_29, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNumber",905,G__G__Base1_154_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRange",781,G__G__Base1_154_0_31, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - x1 d - 'Double_t' 1 - y1 "
"d - 'Double_t' 1 - x2 d - 'Double_t' 1 - y2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRangeAxis",1186,G__G__Base1_154_0_32, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPadPar",856,G__G__Base1_154_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - xlow d - 'Double_t' 1 - ylow "
"d - 'Double_t' 1 - xup d - 'Double_t' 1 - yup", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetXlowNDC",927,G__G__Base1_154_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetYlowNDC",928,G__G__Base1_154_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetWNDC",588,G__G__Base1_154_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetHNDC",573,G__G__Base1_154_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetWw",494,G__G__Base1_154_0_38, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetWh",479,G__G__Base1_154_0_39, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAbsXlowNDC",1205,G__G__Base1_154_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAbsYlowNDC",1206,G__G__Base1_154_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAbsWNDC",866,G__G__Base1_154_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAbsHNDC",851,G__G__Base1_154_0_43, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAspectRatio",1407,G__G__Base1_154_0_44, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPhi",577,G__G__Base1_154_0_45, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTheta",790,G__G__Base1_154_0_46, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetUxmin",817,G__G__Base1_154_0_47, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetUymin",818,G__G__Base1_154_0_48, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetUxmax",819,G__G__Base1_154_0_49, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetUymax",820,G__G__Base1_154_0_50, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetGridx",798,G__G__Base1_154_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetGridy",799,G__G__Base1_154_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTickx",803,G__G__Base1_154_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTicky",804,G__G__Base1_154_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetX1",425,G__G__Base1_154_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetX2",426,G__G__Base1_154_0_56, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetY1",426,G__G__Base1_154_0_57, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetY2",427,G__G__Base1_154_0_58, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetListOfPrimitives",1949,G__G__Base1_154_0_59, 85, G__get_linked_tagnum(&G__G__Base1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetListOfExecs",1385,G__G__Base1_154_0_60, 85, G__get_linked_tagnum(&G__G__Base1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPrimitive",1241,G__G__Base1_154_0_61, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSelected",1097,G__G__Base1_154_0_62, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPad",565,G__G__Base1_154_0_63, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - subpadnumber", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPadPointer",1302,G__G__Base1_154_0_64, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPadSave",964,G__G__Base1_154_0_65, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSelectedPad",1374,G__G__Base1_154_0_66, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetView",699,G__G__Base1_154_0_67, 85, G__get_linked_tagnum(&G__G__Base1LN_TView), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLogx",698,G__G__Base1_154_0_68, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLogy",699,G__G__Base1_154_0_69, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLogz",700,G__G__Base1_154_0_70, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMother",911,G__G__Base1_154_0_71, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPadPaint",1073,G__G__Base1_154_0_74, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPixmapID",1052,G__G__Base1_154_0_75, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetView3D",818,G__G__Base1_154_0_76, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasCrosshair",1226,G__G__Base1_154_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HighLight",888,G__G__Base1_154_0_78, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 'kRed' col g - 'Bool_t' 0 'kTRUE' set", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasFixedAspectRatio",1899,G__G__Base1_154_0_79, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsBatch",670,G__G__Base1_154_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsBeingResized",1399,G__G__Base1_154_0_81, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEditable",982,G__G__Base1_154_0_82, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsModified",989,G__G__Base1_154_0_83, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsRetained",1000,G__G__Base1_154_0_84, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsVertical",1014,G__G__Base1_154_0_85, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   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("Modified",801,G__G__Base1_154_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '1' flag", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("OpaqueMoving",1243,G__G__Base1_154_0_88, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("OpaqueResizing",1462,G__G__Base1_154_0_89, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PadtoX",592,G__G__Base1_154_0_90, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PadtoY",593,G__G__Base1_154_0_91, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintBorderPS",1277,G__G__Base1_154_0_93, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - xl d - 'Double_t' 0 - yl "
"d - 'Double_t' 0 - xt d - 'Double_t' 0 - yt "
"i - 'Int_t' 0 - bmode i - 'Int_t' 0 - bsize "
"i - 'Int_t' 0 - dark i - 'Int_t' 0 - light", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintBox",805,G__G__Base1_154_0_94, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintFillArea",1276,G__G__Base1_154_0_95, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintFillArea",1276,G__G__Base1_154_0_96, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPadFrame",1276,G__G__Base1_154_0_97, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintLine",900,G__G__Base1_154_0_98, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintLineNDC",1113,G__G__Base1_154_0_99, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - u1 d - 'Double_t' 0 - v1 "
"d - 'Double_t' 0 - u2 d - 'Double_t' 0 - v2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintLine3D",1019,G__G__Base1_154_0_100, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - p1 F - 'Float_t' 0 - p2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintLine3D",1019,G__G__Base1_154_0_101, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPolyLine",1320,G__G__Base1_154_0_102, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPolyLine",1320,G__G__Base1_154_0_103, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPolyLine3D",1439,G__G__Base1_154_0_104, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPolyLineNDC",1533,G__G__Base1_154_0_105, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPolyMarker",1538,G__G__Base1_154_0_106, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintPolyMarker",1538,G__G__Base1_154_0_107, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintModified",1309,G__G__Base1_154_0_108, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintText",929,G__G__Base1_154_0_109, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintTextNDC",1142,G__G__Base1_154_0_110, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - u d - 'Double_t' 0 - v "
"C - - 10 - text", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PixeltoX",829,G__G__Base1_154_0_111, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - px", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PixeltoY",830,G__G__Base1_154_0_112, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Pop",303,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' filename", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Print",525,G__G__Base1_154_0_115, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Range",493,G__G__Base1_154_0_116, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RangeAxis",898,G__G__Base1_154_0_117, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RedrawAxis",1018,G__G__Base1_154_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResetView3D",1045,G__G__Base1_154_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' view", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResizePad",903,G__G__Base1_154_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SaveAs",579,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"\"' filename C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBatch",782,G__G__Base1_154_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' batch", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBorderMode",1295,G__G__Base1_154_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - bordermode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBorderSize",1317,G__G__Base1_154_0_125, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - bordersize", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCanvas",904,G__G__Base1_154_0_126, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCanvasSize",1315,G__G__Base1_154_0_127, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - ww h - 'UInt_t' 0 - wh", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCrosshair",1242,G__G__Base1_154_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' crhair", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCursor",938,G__G__Base1_154_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ECursor' - 0 - cursor", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetDoubleBuffer",1505,G__G__Base1_154_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' mode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetEditable",1094,G__G__Base1_154_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' mode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetFixedAspectRatio",1915,G__G__Base1_154_0_132, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' fixed", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGrid",690,G__G__Base1_154_0_133, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1' valuex i - 'Int_t' 0 '1' valuey", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGridx",810,G__G__Base1_154_0_134, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGridy",811,G__G__Base1_154_0_135, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLogx",710,G__G__Base1_154_0_136, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLogy",711,G__G__Base1_154_0_137, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLogz",712,G__G__Base1_154_0_138, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPad",577,G__G__Base1_154_0_139, 121, -1, -1, 0, 9, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 - xlow d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - xup d - 'Double_t' 0 - yup "
"s - 'Color_t' 0 '35' color s - 'Short_t' 0 '5' bordersize "
"s - 'Short_t' 0 '-1' bordermode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPad",577,G__G__Base1_154_0_140, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xlow d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - xup d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetAttFillPS",1151,G__G__Base1_154_0_141, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color s - 'Style_t' 0 - style", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetAttLinePS",1152,G__G__Base1_154_0_142, 121, -1, -1, 0, 3, 1, 1, 0, 
"s - 'Color_t' 0 - color s - 'Style_t' 0 - style "
"s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetAttMarkerPS",1370,G__G__Base1_154_0_143, 121, -1, -1, 0, 3, 1, 1, 0, 
"s - 'Color_t' 0 - color s - 'Style_t' 0 - style "
"f - 'Size_t' 0 - msize", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetAttTextPS",1181,G__G__Base1_154_0_144, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - align f - 'Float_t' 0 - angle "
"s - 'Color_t' 0 - color s - 'Style_t' 0 - font "
"f - 'Float_t' 0 - tsize", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetName",685,G__G__Base1_154_0_145, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSelected",1109,G__G__Base1_154_0_146, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTicks",810,G__G__Base1_154_0_147, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1' valuex i - 'Int_t' 0 '1' valuey", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTickx",815,G__G__Base1_154_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTicky",816,G__G__Base1_154_0_149, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' value", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTitle",814,G__G__Base1_154_0_150, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTheta",802,G__G__Base1_154_0_151, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '30' theta", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPhi",589,G__G__Base1_154_0_152, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '30' phi", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetToolTipText",1436,G__G__Base1_154_0_153, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text l - 'Long_t' 0 '1000' delayms", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetVertical",1126,G__G__Base1_154_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vert", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetView",711,G__G__Base1_154_0_155, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TView' - 0 '0' view", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetViewer3D",1045,G__G__Base1_154_0_156, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualViewer3D' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WaitPrimitive",1358,G__G__Base1_154_0_157, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"\"' pname C - - 10 '\"\"' emode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Update",611,G__G__Base1_154_0_158, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UtoAbsPixel",1104,G__G__Base1_154_0_159, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - u", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("VtoAbsPixel",1105,G__G__Base1_154_0_160, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UtoPixel",826,G__G__Base1_154_0_161, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - u", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("VtoPixel",827,G__G__Base1_154_0_162, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("XtoAbsPixel",1107,G__G__Base1_154_0_163, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("YtoAbsPixel",1108,G__G__Base1_154_0_164, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("XtoPad",592,G__G__Base1_154_0_165, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("YtoPad",593,G__G__Base1_154_0_166, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("XtoPixel",829,G__G__Base1_154_0_167, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("YtoPixel",830,G__G__Base1_154_0_168, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateToolTip",1311,G__G__Base1_154_0_169, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 3, 1, 1, 0, 
"U 'TBox' - 10 - b C - - 10 - text "
"l - 'Long_t' 0 - delayms", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeleteToolTip",1310,G__G__Base1_154_0_170, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - tip", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResetToolTip",1230,G__G__Base1_154_0_171, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - tip", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CloseToolTip",1217,G__G__Base1_154_0_172, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - tip", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetViewer3D",1033,G__G__Base1_154_0_173, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' type", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasViewer3D",1029,G__G__Base1_154_0_174, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReleaseViewer3D",1450,G__G__Base1_154_0_175, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' type", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetGLDevice",1027,G__G__Base1_154_0_176, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCopyGLDevice",1450,G__G__Base1_154_0_177, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - copy", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Pad",277,G__G__Base1_154_0_178, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPad), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualPad*& (*)())(&TVirtualPad::Pad) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_154_0_179, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualPad::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_154_0_180, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPad::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_154_0_181, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualPad::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_154_0_182, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPad::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_154_0_186, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_154_0_187, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPad::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_154_0_188, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPad::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_154_0_189, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPad::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_154_0_190, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPad::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualPad", 1230, G__G__Base1_154_0_191, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTControlBarImp(void) {
   /* TControlBarImp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp));
   G__memfunc_setup("TControlBarImp",1392,G__G__Base1_159_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp), -1, 0, 2, 1, 1, 0, 
"U 'TControlBar' - 0 - c C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TControlBarImp",1392,G__G__Base1_159_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp), -1, 0, 4, 1, 1, 0, 
"U 'TControlBar' - 0 - c C - - 10 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetControlBar",1302,G__G__Base1_159_0_3, 85, G__get_linked_tagnum(&G__G__Base1LN_TControlBar), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClicked",975,G__G__Base1_159_0_4, 85, G__get_linked_tagnum(&G__G__Base1LN_TControlBarButton), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Create",596,G__G__Base1_159_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,G__G__Base1_159_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_159_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Base1_159_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Base1_159_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetButtonState",1449,G__G__Base1_159_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetButtonWidth",1448,G__G__Base1_159_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_159_0_12, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TControlBarImp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_159_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TControlBarImp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_159_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TControlBarImp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_159_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TControlBarImp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_159_0_16, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_159_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_159_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_159_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_159_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TControlBarImp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_159_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TControlBarImp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_159_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TControlBarImp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_159_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TControlBarImp::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TControlBarImp", 1392, G__G__Base1_159_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp), -1, 0, 1, 1, 1, 0, "u 'TControlBarImp' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TControlBarImp", 1518, G__G__Base1_159_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_159_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp), -1, 1, 1, 1, 1, 0, "u 'TControlBarImp' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDatime(void) {
   /* TDatime */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TDatime));
   G__memfunc_setup("TDatime",680,G__G__Base1_160_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDatime",680,G__G__Base1_160_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 0, 1, 1, 1, 0, "u 'TDatime' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDatime",680,G__G__Base1_160_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - tloc g - 'Bool_t' 0 'kFALSE' dosDate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDatime",680,G__G__Base1_160_0_4, 105, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - date i - 'Int_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDatime",680,G__G__Base1_160_0_5, 105, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - year i - 'Int_t' 0 - month "
"i - 'Int_t' 0 - day i - 'Int_t' 0 - hour "
"i - 'Int_t' 0 - min i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDatime",680,G__G__Base1_160_0_6, 105, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 0, 1, 1, 1, 0, "C - - 10 - sqlDateTime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base1_160_0_7, 117, G__get_linked_tagnum(&G__G__Base1LN_TDatime), -1, 1, 1, 1, 1, 0, "u 'TDatime' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Base1_160_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Base1_160_0_9, 67, -1, -1, 0, 1, 1, 1, 9, "C - - 0 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsSQLString",1051,G__G__Base1_160_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Convert",737,G__G__Base1_160_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' toGMT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base1_160_0_12, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TDatime' - 1 - datime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Base1_160_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDate",670,G__G__Base1_160_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__G__Base1_160_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYear",689,G__G__Base1_160_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMonth",806,G__G__Base1_160_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDay",574,G__G__Base1_160_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDayOfWeek",1151,G__G__Base1_160_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHour",702,G__G__Base1_160_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinute",914,G__G__Base1_160_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecond",892,G__G__Base1_160_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBuffer",993,G__G__Base1_160_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Base1_160_0_24, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBuffer",982,G__G__Base1_160_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Base1_160_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Base1_160_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - tloc g - 'Bool_t' 0 'kFALSE' dosDate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Base1_160_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - date i - 'Int_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Base1_160_0_29, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - year i - 'Int_t' 0 - month "
"i - 'Int_t' 0 - day i - 'Int_t' 0 - hour "
"i - 'Int_t' 0 - min i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Base1_160_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sqlDateTime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof",624,G__G__Base1_160_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDateTime",1069,G__G__Base1_160_0_32, 121, -1, -1, 0, 3, 3, 1, 0, 
"h - 'UInt_t' 0 - datetime i - 'Int_t' 1 - date "
"i - 'Int_t' 1 - time", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t, Int_t&, Int_t&))(&TDatime::GetDateTime) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_160_0_33, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDatime::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_160_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDatime::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_160_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDatime::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_160_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDatime::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_160_0_37, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_160_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_160_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_160_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_160_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDatime::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_160_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDatime::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_160_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDatime::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_160_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDatime::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDatime", 806, G__G__Base1_160_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEnv(void) {
   /* TEnv */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TEnv));
   G__memfunc_setup("TEnv",381,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TEnv), -1, 0, 1, 1, 4, 0, "u 'TEnv' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TEnv), -1, 1, 1, 1, 4, 0, "u 'TEnv' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("Getvalue",829,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 4, 1, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEnv",381,G__G__Base1_178_0_4, 105, G__get_linked_tagnum(&G__G__Base1LN_TEnv), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTable",776,G__G__Base1_178_0_5, 85, G__get_linked_tagnum(&G__G__Base1LN_THashList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Defined",687,G__G__Base1_178_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRcName",854,G__G__Base1_178_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRcName",866,G__G__Base1_178_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Base1_178_0_9, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - dflt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Base1_178_0_10, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dflt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Base1_178_0_11, 67, -1, -1, 0, 2, 1, 1, 1, 
"C - - 10 - name C - - 10 - dflt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValue",809,G__G__Base1_178_0_12, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - value "
"i 'EEnvLevel' - 0 'kEnvChange' level C - - 10 '0' type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValue",809,G__G__Base1_178_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i 'EEnvLevel' - 0 'kEnvChange' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValue",809,G__G__Base1_178_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValue",809,G__G__Base1_178_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Lookup",634,G__G__Base1_178_0_16, 85, G__get_linked_tagnum(&G__G__Base1LN_TEnvRec), -1, 0, 1, 1, 1, 0, "C - - 10 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFile",764,G__G__Base1_178_0_17, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - fname i 'EEnvLevel' - 0 - level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFile",907,G__G__Base1_178_0_18, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - fname i 'EEnvLevel' - 0 'kEnvAll' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Save",399,G__G__Base1_178_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveLevel",903,G__G__Base1_178_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EEnvLevel' - 0 - level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintEnv",822,G__G__Base1_178_0_22, 121, -1, -1, 0, 1, 1, 1, 8, "i 'EEnvLevel' - 0 'kEnvAll' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreDuplicates",1650,G__G__Base1_178_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ignore", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base1_178_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEnv::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_178_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEnv::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_178_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEnv::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_178_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEnv::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_178_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__Base1_178_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEnv::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_178_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEnv::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_178_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEnv::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_178_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEnv::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEnv", 507, G__G__Base1_178_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEnvRec(void) {
   /* TEnvRec */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TEnvRec));
   G__memfunc_setup("TEnvRec",663,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TEnvRec), -1, 0, 4, 1, 4, 0, 
"C - - 10 - n C - - 10 - v "
"C - - 10 - t i 'EEnvLevel' - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeValue",1091,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"C - - 10 - v C - - 10 - t "
"i 'EEnvLevel' - 0 - l g - 'Bool_t' 0 'kFALSE' append "
"g - 'Bool_t' 0 'kFALSE' ignoredup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExpandValue",1117,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 1, 1, 4, 0, "C - - 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEnvRec",663,G__G__Base1_183_0_5, 105, G__get_linked_tagnum(&G__G__Base1LN_TEnvRec), -1, 0, 0, 1, 1, 0, "", (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("GetValue",797,G__G__Base1_183_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Base1_183_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLevel",792,G__G__Base1_183_0_9, 105, G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_183_0_11, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEnvRec::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_183_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEnvRec::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_183_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEnvRec::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_183_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEnvRec::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_183_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__Base1_183_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEnvRec::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_183_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEnvRec::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_183_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEnvRec::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_183_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEnvRec::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEnvRec", 663, G__G__Base1_183_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TEnvRec), -1, 0, 1, 1, 1, 0, "u 'TEnvRec' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEnvRec", 789, G__G__Base1_183_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_183_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TEnvRec), -1, 1, 1, 1, 1, 0, "u 'TEnvRec' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTInspectorImp(void) {
   /* TInspectorImp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp));
   G__memfunc_setup("TInspectorImp",1329,G__G__Base1_189_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TInspectorImp",1329,G__G__Base1_189_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 10 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hide",378,G__G__Base1_189_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_189_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_189_0_5, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TInspectorImp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_189_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TInspectorImp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_189_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TInspectorImp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_189_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TInspectorImp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_189_0_9, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_189_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_189_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_189_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__Base1_189_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TInspectorImp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_189_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TInspectorImp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_189_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TInspectorImp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_189_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TInspectorImp::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TInspectorImp", 1329, G__G__Base1_189_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp), -1, 0, 1, 1, 1, 0, "u 'TInspectorImp' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TInspectorImp", 1455, G__G__Base1_189_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_189_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp), -1, 1, 1, 1, 1, 0, "u 'TInspectorImp' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGuiFactory(void) {
   /* TGuiFactory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory));
   G__memfunc_setup("TGuiFactory",1105,G__G__Base1_190_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"Batch\"' name C - - 10 '\"Batch GUI Factory\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateApplicationImp",2030,G__G__Base1_190_0_2, 85, G__get_linked_tagnum(&G__G__Base1LN_TApplicationImp), -1, 0, 3, 1, 1, 0, 
"C - - 10 - classname I - - 0 - argc "
"C - - 2 - argv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateCanvasImp",1494,G__G__Base1_190_0_3, 85, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 4, 1, 1, 0, 
"U 'TCanvas' - 0 - c C - - 10 - title "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateCanvasImp",1494,G__G__Base1_190_0_4, 85, G__get_linked_tagnum(&G__G__Base1LN_TCanvasImp), -1, 0, 6, 1, 1, 0, 
"U 'TCanvas' - 0 - c C - - 10 - title "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBrowserImp",1630,G__G__Base1_190_0_5, 85, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 5, 1, 1, 0, 
"U 'TBrowser' - 0 - b C - - 10 - title "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBrowserImp",1630,G__G__Base1_190_0_6, 85, G__get_linked_tagnum(&G__G__Base1LN_TBrowserImp), -1, 0, 7, 1, 1, 0, 
"U 'TBrowser' - 0 - b C - - 10 - title "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateContextMenuImp",2036,G__G__Base1_190_0_7, 85, G__get_linked_tagnum(&G__G__Base1LN_TContextMenuImp), -1, 0, 3, 1, 1, 0, 
"U 'TContextMenu' - 0 - c C - - 10 - name "
"C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateControlBarImp",1904,G__G__Base1_190_0_8, 85, G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp), -1, 0, 2, 1, 1, 0, 
"U 'TControlBar' - 0 - c C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateControlBarImp",1904,G__G__Base1_190_0_9, 85, G__get_linked_tagnum(&G__G__Base1LN_TControlBarImp), -1, 0, 4, 1, 1, 0, 
"U 'TControlBar' - 0 - c C - - 10 - title "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateInspectorImp",1841,G__G__Base1_190_0_10, 85, G__get_linked_tagnum(&G__G__Base1LN_TInspectorImp), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 10 - obj h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_190_0_11, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGuiFactory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_190_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiFactory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_190_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGuiFactory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_190_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGuiFactory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_190_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__Base1_190_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiFactory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_190_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGuiFactory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_190_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiFactory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_190_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGuiFactory::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGuiFactory", 1105, G__G__Base1_190_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory), -1, 0, 1, 1, 1, 0, "u 'TGuiFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGuiFactory", 1231, G__G__Base1_190_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_190_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TGuiFactory), -1, 1, 1, 1, 1, 0, "u 'TGuiFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFileHandler(void) {
   /* TFileHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TFileHandler));
   G__memfunc_setup("TFileHandler",1170,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base1LN_TFileHandler), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileHandler",1170,G__G__Base1_257_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TFileHandler), -1, 0, 2, 1, 1, 0, 
"i - - 0 - fd i - - 0 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFd",458,G__G__Base1_257_0_3, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFd",470,G__G__Base1_257_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - fd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadNotify",1013,G__G__Base1_257_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteNotify",1156,G__G__Base1_257_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasReadInterest",1510,G__G__Base1_257_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasWriteInterest",1653,G__G__Base1_257_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInterest",1146,G__G__Base1_257_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetReadyMask",1412,G__G__Base1_257_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetReadReady",1181,G__G__Base1_257_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWriteReady",1324,G__G__Base1_257_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsReadReady",1069,G__G__Base1_257_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsWriteReady",1212,G__G__Base1_257_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_257_0_18, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_257_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_257_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_257_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_257_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_257_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_257_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_257_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_257_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFileHandler", 1296, G__G__Base1_257_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStyle(void) {
   /* TStyle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TStyle));
   G__memfunc_setup("TStyle",613,G__G__Base1_284_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TStyle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStyle",613,G__G__Base1_284_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TStyle), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStyle",613,G__G__Base1_284_0_3, 105, G__get_linked_tagnum(&G__G__Base1LN_TStyle), -1, 0, 1, 1, 1, 0, "u 'TStyle' - 11 - style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AxisChoice",992,G__G__Base1_284_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 - axis", (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("BuildStyles",1140,G__G__Base1_284_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyle::BuildStyles) ), 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - style", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("cd",199,G__G__Base1_284_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdivisions",1350,G__G__Base1_284_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttDate",967,G__G__Base1_284_0_11, 85, G__get_linked_tagnum(&G__G__Base1LN_TAttText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAxisColor",1204,G__G__Base1_284_0_12, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelColor",1279,G__G__Base1_284_0_13, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelFont",1175,G__G__Base1_284_0_14, 115, -1, G__defined_typename("Style_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelOffset",1383,G__G__Base1_284_0_15, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelSize",1179,G__G__Base1_284_0_16, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitleColor",1313,G__G__Base1_284_0_17, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", "return axis title color of pad title color", (void*) NULL, 0);
   G__memfunc_setup("GetTitleFont",1209,G__G__Base1_284_0_18, 115, -1, G__defined_typename("Style_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", "return axis title font of pad title font", (void*) NULL, 0);
   G__memfunc_setup("GetTitleOffset",1417,G__G__Base1_284_0_19, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", "return axis title offset", (void*) NULL, 0);
   G__memfunc_setup("GetTitleSize",1213,G__G__Base1_284_0_20, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", "return axis title size", (void*) NULL, 0);
   G__memfunc_setup("GetTickLength",1293,G__G__Base1_284_0_21, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBarOffset",1180,G__G__Base1_284_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBarWidth",1077,G__G__Base1_284_0_23, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawBorder",1292,G__G__Base1_284_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndErrorSize",1500,G__G__Base1_284_0_25, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorX",898,G__G__Base1_284_0_26, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasPreferGL",1651,G__G__Base1_284_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasColor",1403,G__G__Base1_284_0_28, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasBorderSize",1909,G__G__Base1_284_0_29, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasBorderMode",1887,G__G__Base1_284_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasDefH",1235,G__G__Base1_284_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasDefW",1250,G__G__Base1_284_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasDefX",1251,G__G__Base1_284_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasDefY",1252,G__G__Base1_284_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColorPalette",1518,G__G__Base1_284_0_35, 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("GetColorModelPS",1459,G__G__Base1_284_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDateX",758,G__G__Base1_284_0_37, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDateY",759,G__G__Base1_284_0_38, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitFormat",1196,G__G__Base1_284_0_39, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHatchesLineWidth",1896,G__G__Base1_284_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHatchesSpacing",1701,G__G__Base1_284_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLegendBorderSize",1896,G__G__Base1_284_0_42, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfColors",1712,G__G__Base1_284_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadColor",1076,G__G__Base1_284_0_44, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadBorderSize",1582,G__G__Base1_284_0_45, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadBorderMode",1560,G__G__Base1_284_0_46, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadBottomMargin",1800,G__G__Base1_284_0_47, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadTopMargin",1478,G__G__Base1_284_0_48, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadLeftMargin",1566,G__G__Base1_284_0_49, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadRightMargin",1681,G__G__Base1_284_0_50, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadGridX",1043,G__G__Base1_284_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadGridY",1044,G__G__Base1_284_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadTickX",1048,G__G__Base1_284_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadTickY",1049,G__G__Base1_284_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFuncColor",1195,G__G__Base1_284_0_55, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFuncStyle",1213,G__G__Base1_284_0_56, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFuncWidth",1196,G__G__Base1_284_0_57, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridColor",1189,G__G__Base1_284_0_58, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridStyle",1207,G__G__Base1_284_0_59, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridWidth",1190,G__G__Base1_284_0_60, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFillColor",1681,G__G__Base1_284_0_61, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameLineColor",1682,G__G__Base1_284_0_62, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFillStyle",1699,G__G__Base1_284_0_63, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameLineStyle",1700,G__G__Base1_284_0_64, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameLineWidth",1683,G__G__Base1_284_0_65, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBorderSize",1796,G__G__Base1_284_0_66, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBorderMode",1774,G__G__Base1_284_0_67, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistFillColor",1598,G__G__Base1_284_0_68, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistLineColor",1599,G__G__Base1_284_0_69, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistFillStyle",1616,G__G__Base1_284_0_70, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistLineStyle",1617,G__G__Base1_284_0_71, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistLineWidth",1600,G__G__Base1_284_0_72, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistMinimumZero",1844,G__G__Base1_284_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistTopMargin",1609,G__G__Base1_284_0_74, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLegoInnerR",1269,G__G__Base1_284_0_75, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberContours",1766,G__G__Base1_284_0_76, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptDate",977,G__G__Base1_284_0_77, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptFile",979,G__G__Base1_284_0_78, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptFit",886,G__G__Base1_284_0_79, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptStat",1007,G__G__Base1_284_0_80, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptTitle",1109,G__G__Base1_284_0_81, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptLogx",1005,G__G__Base1_284_0_82, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptLogy",1006,G__G__Base1_284_0_83, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptLogz",1007,G__G__Base1_284_0_84, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaintTextFormat",1834,G__G__Base1_284_0_85, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaperSize",1203,G__G__Base1_284_0_86, 121, -1, -1, 0, 2, 1, 1, 8, 
"f - 'Float_t' 1 - xsize f - 'Float_t' 1 - ysize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowEventStatus",1863,G__G__Base1_284_0_87, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowEditor",1320,G__G__Base1_284_0_88, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowToolBar",1396,G__G__Base1_284_0_89, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScreenFactor",1503,G__G__Base1_284_0_90, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatColor",1211,G__G__Base1_284_0_91, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatTextColor",1632,G__G__Base1_284_0_92, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatBorderSize",1717,G__G__Base1_284_0_93, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatFont",1107,G__G__Base1_284_0_94, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatFontSize",1518,G__G__Base1_284_0_95, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatStyle",1229,G__G__Base1_284_0_96, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatFormat",1317,G__G__Base1_284_0_97, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatX",788,G__G__Base1_284_0_98, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatY",789,G__G__Base1_284_0_99, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatW",787,G__G__Base1_284_0_100, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatH",772,G__G__Base1_284_0_101, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStripDecimals",1620,G__G__Base1_284_0_102, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimeOffset",1302,G__G__Base1_284_0_103, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "return axis time offset", (void*) NULL, 0);
   G__memfunc_setup("GetTitleAlign",1293,G__G__Base1_284_0_104, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", "return the histogram title TPaveLabel alignment", (void*) NULL, 0);
   G__memfunc_setup("GetTitleFillColor",1704,G__G__Base1_284_0_105, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", "return histogram title fill area color", (void*) NULL, 0);
   G__memfunc_setup("GetTitleTextColor",1734,G__G__Base1_284_0_106, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", "return histogram title text color", (void*) NULL, 0);
   G__memfunc_setup("GetTitleStyle",1331,G__G__Base1_284_0_107, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitleFontSize",1620,G__G__Base1_284_0_108, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return histogram title font size", (void*) NULL, 0);
   G__memfunc_setup("GetTitleBorderSize",1819,G__G__Base1_284_0_109, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", "return border size of histogram title TPaveLabel", (void*) NULL, 0);
   G__memfunc_setup("GetTitleXOffset",1505,G__G__Base1_284_0_110, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return X axis title offset", (void*) NULL, 0);
   G__memfunc_setup("GetTitleXSize",1301,G__G__Base1_284_0_111, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return X axis title size", (void*) NULL, 0);
   G__memfunc_setup("GetTitleYOffset",1506,G__G__Base1_284_0_112, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return Y axis title offset", (void*) NULL, 0);
   G__memfunc_setup("GetTitleYSize",1302,G__G__Base1_284_0_113, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return Y axis title size", (void*) NULL, 0);
   G__memfunc_setup("GetTitleX",890,G__G__Base1_284_0_114, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return left X position of histogram title TPavelabel", (void*) NULL, 0);
   G__memfunc_setup("GetTitleY",891,G__G__Base1_284_0_115, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return left bottom position of histogram title TPavelabel", (void*) NULL, 0);
   G__memfunc_setup("GetTitleW",889,G__G__Base1_284_0_116, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return width of histogram title TPaveLabel", (void*) NULL, 0);
   G__memfunc_setup("GetTitleH",874,G__G__Base1_284_0_117, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "return height of histogram title TPavelabel", (void*) NULL, 0);
   G__memfunc_setup("GetHeaderPS",1036,G__G__Base1_284_0_118, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitlePS",965,G__G__Base1_284_0_119, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineStyleString",1840,G__G__Base1_284_0_120, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 '1' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineScalePS",1331,G__G__Base1_284_0_121, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReading",886,G__G__Base1_284_0_122, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Base1_284_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColorModelPS",1471,G__G__Base1_284_0_125, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitFormat",1208,G__G__Base1_284_0_126, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"5.4g\"' format", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHeaderPS",1048,G__G__Base1_284_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - header", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHatchesLineWidth",1908,G__G__Base1_284_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHatchesSpacing",1713,G__G__Base1_284_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitlePS",977,G__G__Base1_284_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - pstitle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineScalePS",1343,G__G__Base1_284_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '3' scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineStyleString",1852,G__G__Base1_284_0_132, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNdivisions",1362,G__G__Base1_284_0_133, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '510' n C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxisColor",1216,G__G__Base1_284_0_134, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelColor",1291,G__G__Base1_284_0_135, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelFont",1187,G__G__Base1_284_0_136, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 '62' font C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelOffset",1395,G__G__Base1_284_0_137, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.005' offset C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelSize",1191,G__G__Base1_284_0_138, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.04' size C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLegoInnerR",1281,G__G__Base1_284_0_139, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.5' rad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScreenFactor",1515,G__G__Base1_284_0_140, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTickLength",1305,G__G__Base1_284_0_141, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.03' length C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleColor",1325,G__G__Base1_284_0_142, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"X\"' axis", "set axis title color or pad title color", (void*) NULL, 0);
   G__memfunc_setup("SetTitleFont",1221,G__G__Base1_284_0_143, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 '62' font C - 'Option_t' 10 '\"X\"' axis", "set axis title font or pad title font", (void*) NULL, 0);
   G__memfunc_setup("SetTitleOffset",1429,G__G__Base1_284_0_144, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '1' offset C - 'Option_t' 10 '\"X\"' axis", "set axis title offset", (void*) NULL, 0);
   G__memfunc_setup("SetTitleSize",1225,G__G__Base1_284_0_145, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.02' size C - 'Option_t' 10 '\"X\"' axis", "set axis title size or pad title size", (void*) NULL, 0);
   G__memfunc_setup("SetNumberContours",1778,G__G__Base1_284_0_146, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '20' number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptDate",989,G__G__Base1_284_0_147, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' datefl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptFile",991,G__G__Base1_284_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptFit",898,G__G__Base1_284_0_149, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' fit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptLogx",1017,G__G__Base1_284_0_150, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' logx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptLogy",1018,G__G__Base1_284_0_151, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' logy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptLogz",1019,G__G__Base1_284_0_152, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' logz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptStat",1019,G__G__Base1_284_0_153, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptStat",1019,G__G__Base1_284_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptTitle",1121,G__G__Base1_284_0_155, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' tit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBarOffset",1192,G__G__Base1_284_0_156, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.5' baroff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBarWidth",1089,G__G__Base1_284_0_157, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.5' barwidth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDateX",770,G__G__Base1_284_0_158, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.01' x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDateY",771,G__G__Base1_284_0_159, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.01' y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEndErrorSize",1512,G__G__Base1_284_0_160, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '2' np", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetErrorX",910,G__G__Base1_284_0_161, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.5' errorx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasPreferGL",1663,G__G__Base1_284_0_162, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' prefer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawBorder",1304,G__G__Base1_284_0_163, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' drawborder", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasColor",1415,G__G__Base1_284_0_164, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '19' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasBorderSize",1921,G__G__Base1_284_0_165, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasBorderMode",1899,G__G__Base1_284_0_166, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasDefH",1247,G__G__Base1_284_0_167, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '500' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasDefW",1262,G__G__Base1_284_0_168, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '700' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasDefX",1263,G__G__Base1_284_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '10' topx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvasDefY",1264,G__G__Base1_284_0_170, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '10' topy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLegendBorderSize",1908,G__G__Base1_284_0_171, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '4' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadColor",1088,G__G__Base1_284_0_172, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '19' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadBorderSize",1594,G__G__Base1_284_0_173, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadBorderMode",1572,G__G__Base1_284_0_174, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadBottomMargin",1812,G__G__Base1_284_0_175, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.1' margin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadTopMargin",1490,G__G__Base1_284_0_176, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.1' margin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadLeftMargin",1578,G__G__Base1_284_0_177, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.1' margin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadRightMargin",1693,G__G__Base1_284_0_178, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.1' margin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadGridX",1055,G__G__Base1_284_0_179, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - gridx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadGridY",1056,G__G__Base1_284_0_180, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - gridy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadTickX",1060,G__G__Base1_284_0_181, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tickx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadTickY",1061,G__G__Base1_284_0_182, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ticky", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFuncStyle",1225,G__G__Base1_284_0_183, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '1' style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFuncColor",1207,G__G__Base1_284_0_184, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFuncWidth",1208,G__G__Base1_284_0_185, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '4' width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridStyle",1219,G__G__Base1_284_0_186, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '3' style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridColor",1201,G__G__Base1_284_0_187, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '0' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridWidth",1202,G__G__Base1_284_0_188, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameFillColor",1693,G__G__Base1_284_0_189, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLineColor",1694,G__G__Base1_284_0_190, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameFillStyle",1711,G__G__Base1_284_0_191, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' styl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLineStyle",1712,G__G__Base1_284_0_192, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' styl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLineWidth",1695,G__G__Base1_284_0_193, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameBorderSize",1808,G__G__Base1_284_0_194, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameBorderMode",1786,G__G__Base1_284_0_195, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistFillColor",1610,G__G__Base1_284_0_196, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistLineColor",1611,G__G__Base1_284_0_197, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistFillStyle",1628,G__G__Base1_284_0_198, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' styl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistLineStyle",1629,G__G__Base1_284_0_199, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' styl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistLineWidth",1612,G__G__Base1_284_0_200, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '1' width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistMinimumZero",1856,G__G__Base1_284_0_201, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' zero", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistTopMargin",1621,G__G__Base1_284_0_202, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.05' hmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPaintTextFormat",1846,G__G__Base1_284_0_203, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"g\"' format", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPaperSize",1215,G__G__Base1_284_0_204, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TStyle::EPaperSize' - 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPaperSize",1215,G__G__Base1_284_0_205, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '20' xsize f - 'Float_t' 0 '26' ysize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatColor",1223,G__G__Base1_284_0_206, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '19' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatTextColor",1644,G__G__Base1_284_0_207, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatStyle",1241,G__G__Base1_284_0_208, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '1001' style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatBorderSize",1729,G__G__Base1_284_0_209, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '2' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatFont",1119,G__G__Base1_284_0_210, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '62' font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatFontSize",1530,G__G__Base1_284_0_211, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatFormat",1329,G__G__Base1_284_0_212, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"6.4g\"' format", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatX",800,G__G__Base1_284_0_213, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatY",801,G__G__Base1_284_0_214, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatW",799,G__G__Base1_284_0_215, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.19' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatH",784,G__G__Base1_284_0_216, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStripDecimals",1632,G__G__Base1_284_0_217, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' strip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeOffset",1314,G__G__Base1_284_0_218, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - toffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleAlign",1305,G__G__Base1_284_0_219, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '13' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleFillColor",1716,G__G__Base1_284_0_220, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleTextColor",1746,G__G__Base1_284_0_221, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleStyle",1343,G__G__Base1_284_0_222, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '1001' style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleFontSize",1632,G__G__Base1_284_0_223, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleBorderSize",1831,G__G__Base1_284_0_224, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 '2' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleXOffset",1517,G__G__Base1_284_0_225, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleXSize",1313,G__G__Base1_284_0_226, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.02' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleYOffset",1518,G__G__Base1_284_0_227, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleYSize",1314,G__G__Base1_284_0_228, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.02' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleX",902,G__G__Base1_284_0_229, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleY",903,G__G__Base1_284_0_230, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.985' y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleW",901,G__G__Base1_284_0_231, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleH",886,G__G__Base1_284_0_232, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleEventStatus",1768,G__G__Base1_284_0_233, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleEditor",1225,G__G__Base1_284_0_234, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleToolBar",1301,G__G__Base1_284_0_235, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsReading",1186,G__G__Base1_284_0_236, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' reading", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPalette",1019,G__G__Base1_284_0_237, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' ncolors I - 'Int_t' 0 '0' colors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveSource",1024,G__G__Base1_284_0_239, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base1_284_0_240, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStyle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_284_0_241, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_284_0_242, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStyle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_284_0_243, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_284_0_247, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_284_0_248, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_284_0_249, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_284_0_250, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_284_0_251, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyle::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStyle", 739, G__G__Base1_284_0_252, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_284_0_253, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TStyle), -1, 1, 1, 1, 1, 0, "u 'TStyle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualFFT(void) {
   /* TVirtualFFT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT));
   G__memfunc_setup("GetN",366,G__G__Base1_293_0_2, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNdim",680,G__G__Base1_293_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetType",706,G__G__Base1_293_0_4, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSign",689,G__G__Base1_293_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTransformFlag",1622,G__G__Base1_293_0_6, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Init",404,G__G__Base1_293_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - 'Option_t' 10 - flag i - 'Int_t' 0 - sign "
"I - 'Int_t' 10 - kind", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsInplace",888,G__G__Base1_293_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPoints",925,G__G__Base1_293_0_9, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - data g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointReal",1198,G__G__Base1_293_0_10, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - ipoint g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointReal",1198,G__G__Base1_293_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"I - 'Int_t' 10 - ipoint g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointComplex",1538,G__G__Base1_293_0_12, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - ipoint d - 'Double_t' 1 - re "
"d - 'Double_t' 1 - im g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointComplex",1538,G__G__Base1_293_0_13, 121, -1, -1, 0, 4, 1, 1, 8, 
"I - 'Int_t' 10 - ipoint d - 'Double_t' 1 - re "
"d - 'Double_t' 1 - im g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointsReal",1313,G__G__Base1_293_0_14, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointsComplex",1653,G__G__Base1_293_0_15, 121, -1, -1, 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - re D - 'Double_t' 0 - im "
"g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointsComplex",1653,G__G__Base1_293_0_16, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - data g - 'Bool_t' 0 'kFALSE' fromInput", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPoint",822,G__G__Base1_293_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - ipoint d - 'Double_t' 0 - re "
"d - 'Double_t' 0 '0' im", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPoint",822,G__G__Base1_293_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"I - 'Int_t' 10 - ipoint d - 'Double_t' 0 - re "
"d - 'Double_t' 0 '0' im", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPoints",937,G__G__Base1_293_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPointComplex",1550,G__G__Base1_293_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ipoint u 'TComplex' - 1 - c", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPointsComplex",1665,G__G__Base1_293_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - re D - 'Double_t' 10 - im", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Transform",956,G__G__Base1_293_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("FFT",224,G__G__Base1_293_0_23, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT), -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - ndim I - 'Int_t' 0 - n "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) G__func2void( (TVirtualFFT* (*)(Int_t, Int_t*, Option_t*))(&TVirtualFFT::FFT) ), 0);
   G__memfunc_setup("SineCosine",1008,G__G__Base1_293_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT), -1, 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - ndim I - 'Int_t' 0 - n "
"I - 'Int_t' 0 - r2rkind C - 'Option_t' 10 - option", (char*)NULL, (void*) G__func2void( (TVirtualFFT* (*)(Int_t, Int_t*, Int_t*, Option_t*))(&TVirtualFFT::SineCosine) ), 0);
   G__memfunc_setup("GetCurrentTransform",1983,G__G__Base1_293_0_25, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualFFT* (*)())(&TVirtualFFT::GetCurrentTransform) ), 0);
   G__memfunc_setup("SetTransform",1256,G__G__Base1_293_0_26, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualFFT' - 0 - fft", (char*)NULL, (void*) G__func2void( (void (*)(TVirtualFFT*))(&TVirtualFFT::SetTransform) ), 0);
   G__memfunc_setup("GetDefaultFFT",1221,G__G__Base1_293_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualFFT::GetDefaultFFT) ), 0);
   G__memfunc_setup("SetDefaultFFT",1233,G__G__Base1_293_0_28, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 '\"\"' name", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TVirtualFFT::SetDefaultFFT) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_293_0_29, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualFFT::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_293_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualFFT::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_293_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualFFT::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_293_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualFFT::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_293_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_293_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualFFT::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_293_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualFFT::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_293_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualFFT::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_293_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualFFT::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualFFT", 1177, G__G__Base1_293_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_293_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualFFT), -1, 1, 1, 1, 1, 0, "u 'TVirtualFFT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualViewer3D(void) {
   /* TVirtualViewer3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D));
   G__memfunc_setup("PreferLocalFrame",1594,G__G__Base1_311_0_1, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CanLoopOnPrimitives",1941,G__G__Base1_311_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PadPaint",785,G__G__Base1_311_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ObjectPaint",1107,G__G__Base1_311_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginScene",979,G__G__Base1_311_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("BuildingScene",1308,G__G__Base1_311_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EndScene",773,G__G__Base1_311_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddObject",864,G__G__Base1_311_0_8, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer3D' - 11 - buffer G - 'Bool_t' 0 '0' addChildren", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddObject",864,G__G__Base1_311_0_9, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - physicalID u 'TBuffer3D' - 11 - buffer "
"G - 'Bool_t' 0 '0' addChildren", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("OpenComposite",1349,G__G__Base1_311_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer3D' - 11 - buffer G - 'Bool_t' 0 '0' addChildren", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CloseComposite",1449,G__G__Base1_311_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddCompositeOp",1403,G__G__Base1_311_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - operation", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SelectObject",1207,G__G__Base1_311_0_13, 85, G__get_linked_tagnum(&G__G__Base1LN_TObject), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawViewer",1024,G__G__Base1_311_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintObjects",1239,G__G__Base1_311_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCameras",1215,G__G__Base1_311_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCamerasAfterNextUpdate",2739,G__G__Base1_311_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Viewer3D",745,G__G__Base1_311_0_18, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D), -1, 0, 2, 3, 1, 0, 
"U 'TVirtualPad' - 0 '0' pad C - 'Option_t' 10 '\"\"' type", (char*)NULL, (void*) G__func2void( (TVirtualViewer3D* (*)(TVirtualPad*, Option_t*))(&TVirtualViewer3D::Viewer3D) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_311_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualViewer3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_311_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualViewer3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_311_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualViewer3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_311_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualViewer3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_311_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__Base1_311_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualViewer3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_311_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualViewer3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_311_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualViewer3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_311_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualViewer3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualViewer3D", 1698, G__G__Base1_311_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_311_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualViewer3D), -1, 1, 1, 1, 1, 0, "u 'TVirtualViewer3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualGLPainter(void) {
   /* TVirtualGLPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualGLPainter));
   G__memfunc_setup("Paint",508,G__G__Base1_318_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Pan",287,G__G__Base1_318_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PlotSelected",1224,G__G__Base1_318_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPlotInfo",1099,G__G__Base1_318_0_4, 67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Base1_318_0_5, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualGLPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_318_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGLPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_318_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualGLPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_318_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualGLPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_318_0_9, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_318_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_318_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_318_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__Base1_318_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGLPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_318_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGLPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_318_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGLPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_318_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGLPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGLPainter", 1823, G__G__Base1_318_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_318_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualGLPainter), -1, 1, 1, 1, 1, 0, "u 'TVirtualGLPainter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualGLManip(void) {
   /* TVirtualGLManip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualGLManip));
   G__memfunc_setup("Select",608,G__G__Base1_319_0_1, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLCamera' - 11 - camera u 'TGLRect' - 11 - rect "
"u 'TGLBoundingBox' - 11 - sceneBox", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Base1_319_0_2, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualGLManip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_319_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGLManip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_319_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualGLManip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_319_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualGLManip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_319_0_6, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_319_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_319_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_319_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_319_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGLManip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_319_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGLManip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_319_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGLManip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_319_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGLManip::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGLManip", 1601, G__G__Base1_319_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_319_0_15, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualGLManip), -1, 1, 1, 1, 1, 0, "u 'TVirtualGLManip' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLManager(void) {
   /* TGLManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TGLManager));
   G__memfunc_setup("InitGLWindow",1183,G__G__Base1_320_0_2, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "k - 'Window_t' 0 - winID", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateGLContext",1484,G__G__Base1_320_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - winInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AttachOffScreenDevice",2080,G__G__Base1_320_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ctxInd i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResizeOffScreenDevice",2109,G__G__Base1_320_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ctxInd i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SelectOffScreenDevice",2091,G__G__Base1_320_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVirtualXInd",1402,G__G__Base1_320_0_7, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MarkForDirectCopy",1704,G__G__Base1_320_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ctxInd g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExtractViewport",1595,G__G__Base1_320_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ctxInd I - 'Int_t' 0 - vp", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadGLBuffer",1129,G__G__Base1_320_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeCurrent",1121,G__G__Base1_320_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Flush",514,G__G__Base1_320_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeleteGLContext",1483,G__G__Base1_320_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SelectManip",1109,G__G__Base1_320_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"U 'TVirtualGLManip' - 0 - manip U 'TGLCamera' - 10 - camera "
"U 'TGLRect' - 10 - rect U 'TGLBoundingBox' - 10 - sceneBox", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintSingleObject",1717,G__G__Base1_320_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualGLPainter' - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PanObject",886,G__G__Base1_320_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualGLPainter' - 0 - o i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintViewer",1151,G__G__Base1_320_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualViewer3D' - 0 - vv", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PlotSelected",1224,G__G__Base1_320_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"U 'TVirtualGLPainter' - 0 - plot i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPlotInfo",1099,G__G__Base1_320_0_19, 67, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualGLPainter' - 0 - plot i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HighColorFormat",1512,G__G__Base1_320_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Instance",821,G__G__Base1_320_0_21, 85, G__get_linked_tagnum(&G__G__Base1LN_TGLManager), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLManager*& (*)())(&TGLManager::Instance) ), 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TGLManager), -1, 1, 1, 1, 4, 0, "u 'TGLManager' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base1_320_0_24, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_320_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_320_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_320_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_320_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__Base1_320_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_320_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_320_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_320_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLManager", 1056, G__G__Base1_320_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPaintDevice(void) {
   /* TGLPaintDevice */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TGLPaintDevice));
   G__memfunc_setup("MakeCurrent",1121,G__G__Base1_323_0_1, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SwapBuffers",1128,G__G__Base1_323_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPixelFormat",1419,G__G__Base1_323_0_3, 85, G__get_linked_tagnum(&G__G__Base1LN_TGLFormat), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetContext",1029,G__G__Base1_323_0_4, 85, G__get_linked_tagnum(&G__G__Base1LN_TGLContext), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExtractViewport",1595,G__G__Base1_323_0_5, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - vp", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddContext",1006,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGLContext' - 0 - ctx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RemoveContext",1363,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGLContext' - 0 - ctx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Base1_323_0_8, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPaintDevice::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_323_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPaintDevice::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_323_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPaintDevice::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_323_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPaintDevice::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_323_0_12, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_323_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_323_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_323_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__Base1_323_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPaintDevice::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_323_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPaintDevice::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_323_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPaintDevice::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_323_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPaintDevice::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPaintDevice", 1457, G__G__Base1_323_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_323_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TGLPaintDevice), -1, 1, 1, 1, 1, 0, "u 'TGLPaintDevice' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualPadEditor(void) {
   /* TVirtualPadEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadEditor));
   G__memfunc_setup("IsGlobal",781,G__G__Base1_324_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawLine",790,G__G__Base1_324_0_3, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLineNDC",1003,G__G__Base1_324_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,G__G__Base1_324_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawTextNDC",1032,G__G__Base1_324_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillAttributes",1454,G__G__Base1_324_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineAttributes",1455,G__G__Base1_324_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MarkerAttributes",1673,G__G__Base1_324_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TextAttributes",1484,G__G__Base1_324_0_10, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - f - 'Float_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Build",496,G__G__Base1_324_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Base1_324_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,G__G__Base1_324_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteEditors",1325,G__G__Base1_324_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobal",893,G__G__Base1_324_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCanvas",892,G__G__Base1_324_0_16, 85, G__get_linked_tagnum(&G__G__Base1LN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEditorName",1288,G__G__Base1_324_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadEditor::GetEditorName) ), 0);
   G__memfunc_setup("GetPadEditor",1180,G__G__Base1_324_0_18, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadEditor), -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' load", (char*)NULL, (void*) G__func2void( (TVirtualPadEditor* (*)(Bool_t))(&TVirtualPadEditor::GetPadEditor) ), 0);
   G__memfunc_setup("LoadEditor",999,G__G__Base1_324_0_19, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadEditor), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualPadEditor* (*)())(&TVirtualPadEditor::LoadEditor) ), 0);
   G__memfunc_setup("HideEditor",993,G__G__Base1_324_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPadEditor::HideEditor) ), 0);
   G__memfunc_setup("ShowEditor",1032,G__G__Base1_324_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPadEditor::ShowEditor) ), 0);
   G__memfunc_setup("SetPadEditorName",1577,G__G__Base1_324_0_22, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TVirtualPadEditor::SetPadEditorName) ), 0);
   G__memfunc_setup("Terminate",937,G__G__Base1_324_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPadEditor::Terminate) ), 0);
   G__memfunc_setup("UpdateFillAttributes",2065,G__G__Base1_324_0_24, 121, -1, -1, 0, 2, 3, 1, 0, 
"i - 'Int_t' 0 - col i - 'Int_t' 0 - sty", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t))(&TVirtualPadEditor::UpdateFillAttributes) ), 0);
   G__memfunc_setup("UpdateLineAttributes",2066,G__G__Base1_324_0_25, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - col i - 'Int_t' 0 - sty "
"i - 'Int_t' 0 - width", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Int_t))(&TVirtualPadEditor::UpdateLineAttributes) ), 0);
   G__memfunc_setup("UpdateMarkerAttributes",2284,G__G__Base1_324_0_26, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - col i - 'Int_t' 0 - sty "
"f - 'Float_t' 0 - msiz", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Float_t))(&TVirtualPadEditor::UpdateMarkerAttributes) ), 0);
   G__memfunc_setup("UpdateTextAttributes",2095,G__G__Base1_324_0_27, 121, -1, -1, 0, 5, 3, 1, 0, 
"i - 'Int_t' 0 - align f - 'Float_t' 0 - angle "
"i - 'Int_t' 0 - col i - 'Int_t' 0 - font "
"f - 'Float_t' 0 - tsize", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Float_t, Int_t, Int_t, Float_t))(&TVirtualPadEditor::UpdateTextAttributes) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_324_0_28, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualPadEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_324_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_324_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualPadEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_324_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPadEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_324_0_32, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_324_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_324_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_324_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_324_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_324_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPadEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_324_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_324_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPadEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualPadEditor", 1845, G__G__Base1_324_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_324_0_41, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadEditor), -1, 1, 1, 1, 1, 0, "u 'TVirtualPadEditor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualX(void) {
   /* TVirtualX */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualX));
   G__memfunc_setup("TVirtualX",915,G__G__Base1_327_0_1, 105, G__get_linked_tagnum(&G__G__Base1LN_TVirtualX), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVirtualX",915,G__G__Base1_327_0_2, 105, G__get_linked_tagnum(&G__G__Base1LN_TVirtualX), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__Base1_327_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "Y - - 0 '0' display", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearWindow",1119,G__G__Base1_327_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClosePixmap",1125,G__G__Base1_327_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,G__G__Base1_327_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyPixmap",1034,G__G__Base1_327_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - wid i - 'Int_t' 0 - xpos "
"i - 'Int_t' 0 - ypos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateOpenGLContext",1886,G__G__Base1_327_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteOpenGLContext",1885,G__G__Base1_327_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBox",695,G__G__Base1_327_0_10, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - x1 i - 'Int_t' 0 - y1 "
"i - 'Int_t' 0 - x2 i - 'Int_t' 0 - y2 "
"i 'TVirtualX::EBoxMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCellArray",1293,G__G__Base1_327_0_11, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - x1 i - 'Int_t' 0 - y1 "
"i - 'Int_t' 0 - x2 i - 'Int_t' 0 - y2 "
"i - 'Int_t' 0 - nx i - 'Int_t' 0 - ny "
"I - 'Int_t' 0 - ic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFillArea",1166,G__G__Base1_327_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n U 'TPoint' - 0 - xy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLine",790,G__G__Base1_327_0_13, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x1 i - 'Int_t' 0 - y1 "
"i - 'Int_t' 0 - x2 i - 'Int_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyLine",1210,G__G__Base1_327_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n U 'TPoint' - 0 - xy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyMarker",1428,G__G__Base1_327_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n U 'TPoint' - 0 - xy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,G__G__Base1_327_0_16, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"f - 'Float_t' 0 - angle f - 'Float_t' 0 - mgn "
"C - - 10 - text i 'TVirtualX::ETextMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecCommand",1092,G__G__Base1_327_0_17, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "U 'TGWin32Command' - 0 - code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCharacterUp",1394,G__G__Base1_327_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 1 - chupx f - 'Float_t' 1 - chupy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDrawMode",1075,G__G__Base1_327_0_19, 105, G__get_linked_tagnum(&G__G__Base1LN_TVirtualXcLcLEDrawMode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDoubleBuffer",1493,G__G__Base1_327_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGeometry",1132,G__G__Base1_327_0_21, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - wid i - 'Int_t' 1 - x "
"i - 'Int_t' 1 - y h - 'UInt_t' 1 - w "
"h - 'UInt_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisplayName",1111,G__G__Base1_327_0_22, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNativeEvent",1417,G__G__Base1_327_0_23, 107, -1, G__defined_typename("Handle_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPixel",802,G__G__Base1_327_0_24, 107, -1, G__defined_typename("ULong_t"), 0, 1, 1, 1, 0, "s - 'Color_t' 0 - cindex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlanes",899,G__G__Base1_327_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 1 - nplanes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRGB",507,G__G__Base1_327_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - index f - 'Float_t' 1 - r "
"f - 'Float_t' 1 - g f - 'Float_t' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextExtent",1341,G__G__Base1_327_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h "
"C - - 0 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFontAscent",1301,G__G__Base1_327_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFontDescent",1405,G__G__Base1_327_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextMagnitude",1635,G__G__Base1_327_0_30, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWindowID",1061,G__G__Base1_327_0_31, 107, -1, G__defined_typename("Window_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasTTFonts",974,G__G__Base1_327_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitWindow",1036,G__G__Base1_327_0_33, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - window", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWindow",897,G__G__Base1_327_0_34, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"k - 'ULong_t' 0 - qwid h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddPixmap",888,G__G__Base1_327_0_35, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"k - 'ULong_t' 0 - pixid h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveWindow",1254,G__G__Base1_327_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - qwid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveWindow",1039,G__G__Base1_327_0_37, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - wid i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenPixmap",1025,G__G__Base1_327_0_38, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QueryPointer",1271,G__G__Base1_327_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 1 - ix i - 'Int_t' 1 - iy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadGIF",594,G__G__Base1_327_0_40, 107, -1, G__defined_typename("Pixmap_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x0 i - 'Int_t' 0 - y0 "
"C - - 10 - file k - 'Window_t' 0 '0' id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RequestLocator",1469,G__G__Base1_327_0_41, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - mode i - 'Int_t' 0 - ctyp "
"i - 'Int_t' 1 - x i - 'Int_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RequestString",1376,G__G__Base1_327_0_42, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"C - - 0 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RescaleWindow",1335,G__G__Base1_327_0_43, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - wid h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizePixmap",1249,G__G__Base1_327_0_44, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - wid h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeWindow",1258,G__G__Base1_327_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectWindow",1240,G__G__Base1_327_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectPixmap",1231,G__G__Base1_327_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - qpixid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCharacterUp",1406,G__G__Base1_327_0_48, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - chupx f - 'Float_t' 0 - chupy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClipOFF",911,G__G__Base1_327_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClipRegion",1304,G__G__Base1_327_0_50, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - wid i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCursor",938,G__G__Base1_327_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - win i 'ECursor' - 0 - cursor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDoubleBuffer",1505,G__G__Base1_327_0_52, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - wid i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDoubleBufferOFF",1724,G__G__Base1_327_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDoubleBufferON",1662,G__G__Base1_327_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawMode",1087,G__G__Base1_327_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TVirtualX::EDrawMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillColor",1202,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - cindex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillStyle",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - style", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - cindex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineType",1110,G__G__Base1_327_0_59, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - dash", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - linestyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - width", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerColor",1421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - cindex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerSize",1321,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - markersize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerStyle",1439,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - markerstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOpacity",1029,G__G__Base1_327_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - percent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRGB",519,G__G__Base1_327_0_66, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - cindex f - 'Float_t' 0 - r "
"f - 'Float_t' 0 - g f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextAlign",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 '11' talign", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - cindex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,G__G__Base1_327_0_69, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 0 - fontname i 'TVirtualX::ETextSetMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 - fontnumber", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextMagnitude",1647,G__G__Base1_327_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - mgn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextSize",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - textsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateWindow",1243,G__G__Base1_327_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Warp",410,G__G__Base1_327_0_74, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - ix i - 'Int_t' 0 - iy "
"k - 'Window_t' 0 '0' id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteGIF",737,G__G__Base1_327_0_75, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 0 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WritePixmap",1146,G__G__Base1_327_0_76, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - wid h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h C - - 0 - pxname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentWindow",1659,G__G__Base1_327_0_77, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsExtension",1837,G__G__Base1_327_0_78, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - ext", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWindowAttributes",1983,G__G__Base1_327_0_79, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id u 'WindowAttributes_t' - 1 - attr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapWindow",918,G__G__Base1_327_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapSubwindows",1363,G__G__Base1_327_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapRaised",886,G__G__Base1_327_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnmapWindow",1145,G__G__Base1_327_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyWindow",1378,G__G__Base1_327_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroySubwindows",1823,G__G__Base1_327_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RaiseWindow",1132,G__G__Base1_327_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerWindow",1153,G__G__Base1_327_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveWindow",1039,G__G__Base1_327_0_88, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveResizeWindow",1665,G__G__Base1_327_0_89, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Window_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeWindow",1258,G__G__Base1_327_0_90, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IconifyWindow",1353,G__G__Base1_327_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NeedRedraw",993,G__G__Base1_327_0_92, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - tgwindow g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReparentWindow",1465,G__G__Base1_327_0_93, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Window_t' 0 - pid "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowBackground",1956,G__G__Base1_327_0_94, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'ULong_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowBackgroundPixmap",2579,G__G__Base1_327_0_95, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Pixmap_t' 0 - pxm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateWindow",1228,G__G__Base1_327_0_96, 107, -1, G__defined_typename("Window_t"), 0, 11, 1, 1, 0, 
"k - 'Window_t' 0 - parent i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h h - 'UInt_t' 0 - border "
"i - 'Int_t' 0 - depth h - 'UInt_t' 0 - clss "
"Y - - 0 - visual U 'SetWindowAttributes_t' - 0 - attr "
"h - 'UInt_t' 0 - wtype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenDisplay",1128,G__G__Base1_327_0_97, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dpyName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseDisplay",1228,G__G__Base1_327_0_98, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDisplay",1014,G__G__Base1_327_0_99, 107, -1, G__defined_typename("Display_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVisual",916,G__G__Base1_327_0_100, 107, -1, G__defined_typename("Visual_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScreen",896,G__G__Base1_327_0_101, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDepth",789,G__G__Base1_327_0_102, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScreenWidthMM",1274,G__G__Base1_327_0_103, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColormap",1117,G__G__Base1_327_0_104, 107, -1, G__defined_typename("Colormap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InternAtom",1025,G__G__Base1_327_0_105, 107, -1, G__defined_typename("Atom_t"), 0, 2, 1, 1, 0, 
"C - - 10 - atom_name g - 'Bool_t' 0 - only_if_exist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultRootWindow",2049,G__G__Base1_327_0_106, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParent",906,G__G__Base1_327_0_107, 107, -1, G__defined_typename("Window_t"), 0, 1, 1, 1, 8, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadQueryFont",1325,G__G__Base1_327_0_108, 107, -1, G__defined_typename("FontStruct_t"), 0, 1, 1, 1, 0, "C - - 10 - font_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFontHandle",1283,G__G__Base1_327_0_109, 107, -1, G__defined_typename("FontH_t"), 0, 1, 1, 1, 0, "k - 'FontStruct_t' 0 - fs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteFont",1002,G__G__Base1_327_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'FontStruct_t' 0 - fs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateGC",734,G__G__Base1_327_0_111, 107, -1, G__defined_typename("GContext_t"), 0, 2, 1, 1, 0, 
"k - 'Drawable_t' 0 - id U 'GCValues_t' - 0 - gval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeGC",720,G__G__Base1_327_0_112, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'GContext_t' 0 - gc U 'GCValues_t' - 0 - gval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyGC",549,G__G__Base1_327_0_113, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'GContext_t' 0 - org k - 'GContext_t' 0 - dest "
"h - 'Mask_t' 0 - mask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteGC",733,G__G__Base1_327_0_114, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'GContext_t' 0 - gc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateCursor",1234,G__G__Base1_327_0_115, 107, -1, G__defined_typename("Cursor_t"), 0, 1, 1, 1, 0, "i 'ECursor' - 0 - cursor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCursor",938,G__G__Base1_327_0_116, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Cursor_t' 0 - curid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePixmap",1219,G__G__Base1_327_0_117, 107, -1, G__defined_typename("Pixmap_t"), 0, 3, 1, 1, 0, 
"k - 'Drawable_t' 0 - id h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePixmap",1219,G__G__Base1_327_0_118, 107, -1, G__defined_typename("Pixmap_t"), 0, 7, 1, 1, 0, 
"k - 'Drawable_t' 0 - id C - - 10 - bitmap "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"k - 'ULong_t' 0 - forecolor k - 'ULong_t' 0 - backcolor "
"i - 'Int_t' 0 - depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBitmap",1201,G__G__Base1_327_0_119, 107, -1, G__defined_typename("Pixmap_t"), 0, 4, 1, 1, 0, 
"k - 'Drawable_t' 0 - id C - - 10 - bitmap "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeletePixmap",1218,G__G__Base1_327_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - pmap", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePictureFromFile",2116,G__G__Base1_327_0_121, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"k - 'Drawable_t' 0 - id C - - 10 - filename "
"k - 'Pixmap_t' 1 - pict k - 'Pixmap_t' 1 - pict_mask "
"u 'PictureAttributes_t' - 1 - attr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePictureFromData",2110,G__G__Base1_327_0_122, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"k - 'Drawable_t' 0 - id C - - 2 - data "
"k - 'Pixmap_t' 1 - pict k - 'Pixmap_t' 1 - pict_mask "
"u 'PictureAttributes_t' - 1 - attr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePixmapFromData",2001,G__G__Base1_327_0_123, 107, -1, G__defined_typename("Pixmap_t"), 0, 3, 1, 1, 0, 
"B - - 0 - bits h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadPictureDataFromFile",2278,G__G__Base1_327_0_124, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 3 - ret_data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeletePictureData",1705,G__G__Base1_327_0_125, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDashes",900,G__G__Base1_327_0_126, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - offset "
"C - - 10 - dash_list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParseColor",1018,G__G__Base1_327_0_127, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"k - 'Colormap_t' 0 - cmap C - - 10 - cname "
"u 'ColorStruct_t' - 1 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AllocColor",1002,G__G__Base1_327_0_128, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"k - 'Colormap_t' 0 - cmap u 'ColorStruct_t' - 1 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QueryColor",1045,G__G__Base1_327_0_129, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Colormap_t' 0 - cmap u 'ColorStruct_t' - 1 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeColor",897,G__G__Base1_327_0_130, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Colormap_t' 0 - cmap k - 'ULong_t' 0 - pixel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EventsPending",1338,G__G__Base1_327_0_131, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextEvent",929,G__G__Base1_327_0_132, 121, -1, -1, 0, 1, 1, 1, 0, "u 'Event_t' - 1 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Bell",383,G__G__Base1_327_0_133, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - percent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyArea",788,G__G__Base1_327_0_134, 121, -1, -1, 0, 9, 1, 1, 0, 
"k - 'Drawable_t' 0 - src k - 'Drawable_t' 0 - dest "
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - src_x "
"i - 'Int_t' 0 - src_y h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height i - 'Int_t' 0 - dest_x "
"i - 'Int_t' 0 - dest_y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeWindowAttributes",2277,G__G__Base1_327_0_135, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id U 'SetWindowAttributes_t' - 0 - attr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeProperty",1451,G__G__Base1_327_0_136, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Atom_t' 0 - property "
"k - 'Atom_t' 0 - type B - 'UChar_t' 0 - data "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLine",790,G__G__Base1_327_0_137, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x1 i - 'Int_t' 0 - y1 "
"i - 'Int_t' 0 - x2 i - 'Int_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearArea",864,G__G__Base1_327_0_138, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Window_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckEvent",992,G__G__Base1_327_0_139, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id i 'EGEventType' - 0 - type "
"u 'Event_t' - 1 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendEvent",908,G__G__Base1_327_0_140, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WMDeleteNotify",1392,G__G__Base1_327_0_141, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKeyAutoRepeat",1615,G__G__Base1_327_0_142, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GrabKey",677,G__G__Base1_327_0_143, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Window_t' 0 - id i - 'Int_t' 0 - keycode "
"h - 'UInt_t' 0 - modifier g - 'Bool_t' 0 'kTRUE' grab", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GrabButton",1016,G__G__Base1_327_0_144, 121, -1, -1, 0, 7, 1, 1, 0, 
"k - 'Window_t' 0 - id i 'EMouseButton' - 0 - button "
"h - 'UInt_t' 0 - modifier h - 'UInt_t' 0 - evmask "
"k - 'Window_t' 0 - confine k - 'Cursor_t' 0 - cursor "
"g - 'Bool_t' 0 'kTRUE' grab", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GrabPointer",1117,G__G__Base1_327_0_145, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Window_t' 0 - id h - 'UInt_t' 0 - evmask "
"k - 'Window_t' 0 - confine k - 'Cursor_t' 0 - cursor "
"g - 'Bool_t' 0 'kTRUE' grab g - 'Bool_t' 0 'kTRUE' owner_events", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowName",1317,G__G__Base1_327_0_146, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id C - - 0 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIconName",1078,G__G__Base1_327_0_147, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id C - - 0 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIconPixmap",1316,G__G__Base1_327_0_148, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Pixmap_t' 0 - pix", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClassHints",1320,G__G__Base1_327_0_149, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id C - - 0 - className "
"C - - 0 - resourceName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMWMHints",1059,G__G__Base1_327_0_150, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Window_t' 0 - id h - 'UInt_t' 0 - value "
"h - 'UInt_t' 0 - funcs h - 'UInt_t' 0 - input", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWMPosition",1317,G__G__Base1_327_0_151, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWMSize",875,G__G__Base1_327_0_152, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWMSizeHints",1393,G__G__Base1_327_0_153, 121, -1, -1, 0, 7, 1, 1, 0, 
"k - 'Window_t' 0 - id h - 'UInt_t' 0 - wmin "
"h - 'UInt_t' 0 - hmin h - 'UInt_t' 0 - wmax "
"h - 'UInt_t' 0 - hmax h - 'UInt_t' 0 - winc "
"h - 'UInt_t' 0 - hinc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWMState",977,G__G__Base1_327_0_154, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id i 'EInitialState' - 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWMTransientHint",1819,G__G__Base1_327_0_155, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Window_t' 0 - main_id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawString",1029,G__G__Base1_327_0_156, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"C - - 10 - s i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TextWidth",933,G__G__Base1_327_0_157, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font C - - 10 - s "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFontProperties",1764,G__G__Base1_327_0_158, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font i - 'Int_t' 1 - max_ascent "
"i - 'Int_t' 1 - max_descent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGCValues",1050,G__G__Base1_327_0_159, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'GContext_t' 0 - gc u 'GCValues_t' - 1 - gval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFontStruct",1340,G__G__Base1_327_0_160, 107, -1, G__defined_typename("FontStruct_t"), 0, 1, 1, 1, 0, "k - 'FontH_t' 0 - fh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeFontStruct",1438,G__G__Base1_327_0_161, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'FontStruct_t' 0 - fs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearWindow",1119,G__G__Base1_327_0_162, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeysymToKeycode",1545,G__G__Base1_327_0_163, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - keysym", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRectangle",1308,G__G__Base1_327_0_164, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawRectangle",1315,G__G__Base1_327_0_165, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSegments",1236,G__G__Base1_327_0_166, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"U 'Segment_t' - 0 - seg i - 'Int_t' 0 - nseg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectInput",1136,G__G__Base1_327_0_167, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - id h - 'UInt_t' 0 - evmask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInputFocus",1328,G__G__Base1_327_0_168, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInputFocus",1340,G__G__Base1_327_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrimarySelectionOwner",2485,G__G__Base1_327_0_170, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPrimarySelectionOwner",2497,G__G__Base1_327_0_171, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConvertPrimarySelection",2411,G__G__Base1_327_0_172, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Atom_t' 0 - clipboard "
"k - 'Time_t' 0 - when", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LookupString",1265,G__G__Base1_327_0_173, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'Event_t' - 0 - event C - - 0 - buf "
"i - 'Int_t' 0 - buflen h - 'UInt_t' 1 - keysym", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPasteBuffer",1399,G__G__Base1_327_0_174, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Atom_t' 0 - atom "
"u 'TString' - 1 - text i - 'Int_t' 1 - nchar "
"g - 'Bool_t' 0 - del", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TranslateCoordinates",2089,G__G__Base1_327_0_175, 121, -1, -1, 0, 7, 1, 1, 0, 
"k - 'Window_t' 0 - src k - 'Window_t' 0 - dest "
"i - 'Int_t' 0 - src_x i - 'Int_t' 0 - src_y "
"i - 'Int_t' 1 - dest_x i - 'Int_t' 1 - dest_y "
"k - 'Window_t' 1 - child", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWindowSize",1331,G__G__Base1_327_0_176, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Drawable_t' 0 - id i - 'Int_t' 1 - x "
"i - 'Int_t' 1 - y h - 'UInt_t' 1 - w "
"h - 'UInt_t' 1 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillPolygon",1135,G__G__Base1_327_0_177, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'GContext_t' 0 - gc "
"U 'Point_t' - 0 - points i - 'Int_t' 0 - npnt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QueryPointer",1271,G__G__Base1_327_0_178, 121, -1, -1, 0, 8, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Window_t' 1 - rootw "
"k - 'Window_t' 1 - childw i - 'Int_t' 1 - root_x "
"i - 'Int_t' 1 - root_y i - 'Int_t' 1 - win_x "
"i - 'Int_t' 1 - win_y h - 'UInt_t' 1 - mask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetForeground",1351,G__G__Base1_327_0_179, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'GContext_t' 0 - gc k - 'ULong_t' 0 - foreground", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClipRectangles",1724,G__G__Base1_327_0_180, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y U 'Rectangle_t' - 0 - recs "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Base1_327_0_181, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRegion",1208,G__G__Base1_327_0_182, 107, -1, G__defined_typename("Region_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyRegion",1358,G__G__Base1_327_0_183, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Region_t' 0 - reg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnionRectWithRegion",1943,G__G__Base1_327_0_184, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'Rectangle_t' - 0 - rect k - 'Region_t' 0 - src "
"k - 'Region_t' 0 - dest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PolygonRegion",1356,G__G__Base1_327_0_185, 107, -1, G__defined_typename("Region_t"), 0, 3, 1, 1, 0, 
"U 'Point_t' - 0 - points i - 'Int_t' 0 - np "
"g - 'Bool_t' 0 - winding", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnionRegion",1133,G__G__Base1_327_0_186, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Region_t' 0 - rega k - 'Region_t' 0 - regb "
"k - 'Region_t' 0 - result", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntersectRegion",1557,G__G__Base1_327_0_187, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Region_t' 0 - rega k - 'Region_t' 0 - regb "
"k - 'Region_t' 0 - result", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SubtractRegion",1452,G__G__Base1_327_0_188, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Region_t' 0 - rega k - 'Region_t' 0 - regb "
"k - 'Region_t' 0 - result", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("XorRegion",925,G__G__Base1_327_0_189, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Region_t' 0 - rega k - 'Region_t' 0 - regb "
"k - 'Region_t' 0 - result", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EmptyRegion",1139,G__G__Base1_327_0_190, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "k - 'Region_t' 0 - reg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PointInRegion",1317,G__G__Base1_327_0_191, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"k - 'Region_t' 0 - reg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EqualRegion",1116,G__G__Base1_327_0_192, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"k - 'Region_t' 0 - rega k - 'Region_t' 0 - regb", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegionBox",1197,G__G__Base1_327_0_193, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Region_t' 0 - reg U 'Rectangle_t' - 0 - rect", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ListFonts",934,G__G__Base1_327_0_194, 67, -1, -1, 2, 3, 1, 1, 0, 
"C - - 10 - fontname i - 'Int_t' 0 - max "
"i - 'Int_t' 1 - count", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeFontNames",1293,G__G__Base1_327_0_195, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 2 - fontlist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateImage",1079,G__G__Base1_327_0_196, 107, -1, G__defined_typename("Drawable_t"), 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetImageSize",1182,G__G__Base1_327_0_197, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Drawable_t' 0 - id h - 'UInt_t' 1 - width "
"h - 'UInt_t' 1 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PutPixel",827,G__G__Base1_327_0_198, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Drawable_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y k - 'ULong_t' 0 - pixel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PutImage",796,G__G__Base1_327_0_199, 121, -1, -1, 0, 9, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"k - 'Drawable_t' 0 - img i - 'Int_t' 0 - dx "
"i - 'Int_t' 0 - dy i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteImage",1078,G__G__Base1_327_0_200, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Drawable_t' 0 - img", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColorBits",1201,G__G__Base1_327_0_201, 66, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Drawable_t' 0 - wid i - 'Int_t' 0 '0' x "
"i - 'Int_t' 0 '0' y h - 'UInt_t' 0 '0' w "
"h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShapeCombineMask",1594,G__G__Base1_327_0_202, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Window_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y k - 'Pixmap_t' 0 - mask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteProperty",1464,G__G__Base1_327_0_203, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - - k - 'Atom_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProperty",1157,G__G__Base1_327_0_204, 105, -1, G__defined_typename("Int_t"), 0, 11, 1, 1, 0, 
"k - 'Window_t' 0 - - k - 'Atom_t' 0 - - "
"l - 'Long_t' 0 - - l - 'Long_t' 0 - - "
"g - 'Bool_t' 0 - - k - 'Atom_t' 0 - - "
"K - 'Atom_t' 0 - - I - 'Int_t' 0 - - "
"K - 'ULong_t' 0 - - K - 'ULong_t' 0 - - "
"B - - 2 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeActivePointerGrab",2303,G__G__Base1_327_0_205, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - - h - 'UInt_t' 0 - - "
"k - 'Cursor_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConvertSelection",1671,G__G__Base1_327_0_206, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Window_t' 0 - - k - 'Atom_t' 1 - - "
"k - 'Atom_t' 1 - - k - 'Atom_t' 1 - - "
"k - 'Time_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelectionOwner",1757,G__G__Base1_327_0_207, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - - k - 'Atom_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeProperties",1651,G__G__Base1_327_0_208, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Window_t' 0 - id k - 'Atom_t' 0 - property "
"k - 'Atom_t' 0 - type i - 'Int_t' 0 - format "
"B - 'UChar_t' 0 - data i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDNDAware",1010,G__G__Base1_327_0_209, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - - K - 'Atom_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTypeList",1130,G__G__Base1_327_0_210, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Window_t' 0 - win k - 'Atom_t' 0 - prop "
"K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindRWindow",1099,G__G__Base1_327_0_211, 107, -1, G__defined_typename("Window_t"), 0, 6, 1, 1, 0, 
"k - 'Window_t' 0 - win k - 'Window_t' 0 - dragwin "
"k - 'Window_t' 0 - input i - - 0 - x "
"i - - 0 - y i - - 0 - maxd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDNDAware",898,G__G__Base1_327_0_212, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"k - 'Window_t' 0 - win K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCmdThread",1064,G__G__Base1_327_0_213, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Instance",821,G__G__Base1_327_0_214, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualX), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualX*& (*)())(&TVirtualX::Instance) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_327_0_215, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualX::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_327_0_216, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualX::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_327_0_217, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualX::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_327_0_218, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualX::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_327_0_222, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_327_0_223, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualX::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_327_0_224, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualX::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_327_0_225, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualX::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_327_0_226, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualX::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TVirtualX", 915, G__G__Base1_327_0_227, (int) ('i'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualX), -1, 0, 1, 1, 1, 0, "u 'TVirtualX' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualX", 1041, G__G__Base1_327_0_228, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_327_0_229, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualX), -1, 1, 1, 1, 1, 0, "u 'TVirtualX' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualPadPainter(void) {
   /* TVirtualPadPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPainter));
   G__memfunc_setup("GetLineColor",1191,G__G__Base1_339_0_1, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLineStyle",1209,G__G__Base1_339_0_2, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLineWidth",1192,G__G__Base1_339_0_3, 115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLineColor",1203,G__G__Base1_339_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - lcolor", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLineStyle",1221,G__G__Base1_339_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - lstyle", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLineWidth",1204,G__G__Base1_339_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFillColor",1190,G__G__Base1_339_0_7, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFillStyle",1208,G__G__Base1_339_0_8, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsTransparent",1358,G__G__Base1_339_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetFillColor",1202,G__G__Base1_339_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - fcolor", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetFillStyle",1220,G__G__Base1_339_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - fstyle", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetOpacity",1029,G__G__Base1_339_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - percent", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextAlign",1200,G__G__Base1_339_0_13, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextAngle",1196,G__G__Base1_339_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextColor",1220,G__G__Base1_339_0_15, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextFont",1116,G__G__Base1_339_0_16, 115, -1, G__defined_typename("Font_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextSize",1120,G__G__Base1_339_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextMagnitude",1635,G__G__Base1_339_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTextAlign",1212,G__G__Base1_339_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 '11' align", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTextAngle",1208,G__G__Base1_339_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' tangle", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTextColor",1232,G__G__Base1_339_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' tcolor", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTextFont",1128,G__G__Base1_339_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 '62' tfont", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTextSize",1132,G__G__Base1_339_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' tsize", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTextSizePixels",1761,G__G__Base1_339_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npixels", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateDrawable",1398,G__G__Base1_339_0_25, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", "gVirtualX->OpenPixmap", (void*) NULL, 3);
   G__memfunc_setup("ClearDrawable",1289,G__G__Base1_339_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", "gVirtualX->Clear()", (void*) NULL, 3);
   G__memfunc_setup("CopyDrawable",1213,G__G__Base1_339_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - device i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DestroyDrawable",1548,G__G__Base1_339_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", "gVirtualX->CloseWindow", (void*) NULL, 3);
   G__memfunc_setup("SelectDrawable",1410,G__G__Base1_339_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - device", "gVirtualX->SelectWindow", (void*) NULL, 3);
   G__memfunc_setup("InitPainter",1127,G__G__Base1_339_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvalidateCS",1175,G__G__Base1_339_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LockPainter",1116,G__G__Base1_339_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLine",790,G__G__Base1_339_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawLineNDC",1003,G__G__Base1_339_0_34, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - u1 d - 'Double_t' 0 - v1 "
"d - 'Double_t' 0 - u2 d - 'Double_t' 0 - v2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawBox",695,G__G__Base1_339_0_35, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i 'TVirtualPadPainter::EBoxMode' - 0 - mode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawFillArea",1166,G__G__Base1_339_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawFillArea",1166,G__G__Base1_339_0_37, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyLine",1210,G__G__Base1_339_0_38, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyLine",1210,G__G__Base1_339_0_39, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyLineNDC",1423,G__G__Base1_339_0_40, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - u "
"D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyMarker",1428,G__G__Base1_339_0_41, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyMarker",1428,G__G__Base1_339_0_42, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawText",819,G__G__Base1_339_0_43, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text i 'TVirtualPadPainter::ETextMode' - 0 - mode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawTextNDC",1032,G__G__Base1_339_0_44, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - u d - 'Double_t' 0 - v "
"C - - 10 - text i 'TVirtualPadPainter::ETextMode' - 0 - mode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SaveImage",882,G__G__Base1_339_0_45, 121, -1, -1, 0, 3, 1, 1, 8, 
"U 'TVirtualPad' - 0 - pad C - - 10 - fileName "
"i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PadPainter",1000,G__G__Base1_339_0_46, 85, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPainter), -1, 0, 1, 3, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) G__func2void( (TVirtualPadPainter* (*)(Option_t*))(&TVirtualPadPainter::PadPainter) ), 0);
   G__memfunc_setup("Class",502,G__G__Base1_339_0_47, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualPadPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_339_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_339_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualPadPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_339_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPadPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base1_339_0_51, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base1_339_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base1_339_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base1_339_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_339_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_339_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPadPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_339_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPadPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_339_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPadPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualPadPainter", 1953, G__G__Base1_339_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base1_339_0_60, (int) ('u'), G__get_linked_tagnum(&G__G__Base1LN_TVirtualPadPainter), -1, 1, 1, 1, 1, 0, "u 'TVirtualPadPainter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualPS(void) {
   /* TVirtualPS */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS), -1, 1, 1, 1, 4, 0, "u 'TVirtualPS' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CellArrayBegin",1380,G__G__Base1_342_0_5, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - W i - 'Int_t' 0 - H "
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - x2 "
"d - 'Double_t' 0 - y1 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CellArrayFill",1286,G__G__Base1_342_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - r i - 'Int_t' 0 - g "
"i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CellArrayEnd",1174,G__G__Base1_342_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Close",502,G__G__Base1_342_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawBox",695,G__G__Base1_342_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawFrame",889,G__G__Base1_342_0_10, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - xl d - 'Double_t' 0 - yl "
"d - 'Double_t' 0 - xt d - 'Double_t' 0 - yt "
"i - 'Int_t' 0 - mode i - 'Int_t' 0 - border "
"i - 'Int_t' 0 - dark i - 'Int_t' 0 - light", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyMarker",1428,G__G__Base1_342_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPolyMarker",1428,G__G__Base1_342_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPS",561,G__G__Base1_342_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - xw "
"F - 'Float_t' 0 - yw", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPS",561,G__G__Base1_342_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - xw "
"D - 'Double_t' 0 - yw", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("NewPage",679,G__G__Base1_342_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Open",402,G__G__Base1_342_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename i - 'Int_t' 0 '-111' type", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Text",421,G__G__Base1_342_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - string", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetColor",811,G__G__Base1_342_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintFast",923,G__G__Base1_342_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nch C - - 10 '\"\"' string", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintStr",838,G__G__Base1_342_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' string", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteInteger",1241,G__G__Base1_342_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i g - 'Bool_t' 0 'kTRUE' space", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteReal",911,G__G__Base1_342_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStream",908,G__G__Base1_342_0_23, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStream",920,G__G__Base1_342_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'basic_ofstream<char,char_traits<char> >' 'ofstream' 0 - os", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetType",718,G__G__Base1_342_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-111' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Base1_342_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base1_342_0_27, 85, G__get_linked_tagnum(&G__G__Base1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualPS::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base1_342_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPS::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base1_342_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualPS::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base1_342_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPS::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base1LN_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__Base1_342_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base1_342_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPS::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base1_342_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPS::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base1_342_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPS::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base1_342_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPS::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualPS", 1116, G__G__Base1_342_0_39, (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__Base1() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kWhite=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kBlack=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kGray=920",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kRed=632",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kGreen=416",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kBlue=600",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kYellow=400",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kMagenta=616",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kCyan=432",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kOrange=800",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kSpring=820",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kTeal=840",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kAzure=860",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kViolet=880",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EColor),-1,-1,1,"kPink=900",0,(char*)NULL);
   G__memvar_setup((void*)(&kTRUE),103,0,1,-1,G__defined_typename("Bool_t"),-1,1,"kTRUE=",0,(char*)NULL);
   G__memvar_setup((void*)(&kFALSE),103,0,1,-1,G__defined_typename("Bool_t"),-1,1,"kFALSE=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxUChar),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMaxUChar=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxChar),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMaxChar=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMinChar),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMinChar=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxUShort),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMaxUShort=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxShort),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMaxShort=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMinShort),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMinShort=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxUInt),104,0,1,-1,G__defined_typename("UInt_t"),-1,1,"kMaxUInt=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxInt),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMaxInt=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMinInt),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kMinInt=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxULong),107,0,1,-1,G__defined_typename("ULong_t"),-1,1,"kMaxULong=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxLong),108,0,1,-1,G__defined_typename("Long_t"),-1,1,"kMaxLong=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMinLong),108,0,1,-1,G__defined_typename("Long_t"),-1,1,"kMinLong=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxULong64),109,0,1,-1,G__defined_typename("ULong64_t"),-1,1,"kMaxULong64=",0,(char*)NULL);
   G__memvar_setup((void*)(&kMaxLong64),110,0,1,-1,G__defined_typename("Long64_t"),-1,1,"kMaxLong64=",0,(char*)NULL);
}

static void G__cpp_setup_global1() {
   G__memvar_setup((void*)(&kMinLong64),110,0,1,-1,G__defined_typename("Long64_t"),-1,1,"kMinLong64=",0,(char*)NULL);
   G__memvar_setup((void*)(&kBitsPerByte),104,0,1,-1,G__defined_typename("size_t"),-1,1,"kBitsPerByte=",0,(char*)NULL);
   G__memvar_setup((void*)(&kNPOS),105,0,1,-1,G__defined_typename("Ssiz_t"),-1,1,"kNPOS=",0,(char*)NULL);
   G__memvar_setup((void*)(&gDebug),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"gDebug=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kCanDelete=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kMustCleanup=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kObjInCanvas=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kIsReferenced=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kHasUUID=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kCannotPick=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kNoContextMenu=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EObjBits),-1,-1,1,"kInvalidObject=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"ROOT_TMathBase=0",1,(char*)NULL);
   G__memvar_setup((void*)(&gApplication),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TApplication),-1,-1,1,"gApplication=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_ELineStyle),-1,-1,1,"kSolid=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_ELineStyle),-1,-1,1,"kDashed=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_ELineStyle),-1,-1,1,"kDotted=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_ELineStyle),-1,-1,1,"kDashDotted=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kDot=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kPlus=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kStar=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kCircle=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kMultiply=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullDotSmall=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullDotMedium=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullDotLarge=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullCircle=20",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullSquare=21",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullTriangleUp=22",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullTriangleDown=23",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kOpenCircle=24",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kOpenSquare=25",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kOpenTriangleUp=26",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kOpenDiamond=27",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kOpenCross=28",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kFullStar=29",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EMarkerStyle),-1,-1,1,"kOpenStar=30",0,(char*)NULL);
   G__memvar_setup((void*)(&gBenchmark),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TBenchmark),-1,-1,1,"gBenchmark=",0,(char*)NULL);
}

static void G__cpp_setup_global2() {
   G__memvar_setup((void*)(&gDirectory),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TDirectory),-1,-1,1,"gDirectory=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel),-1,-1,1,"kEnvGlobal=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel),-1,-1,1,"kEnvUser=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel),-1,-1,1,"kEnvLocal=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel),-1,-1,1,"kEnvChange=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base1LN_EEnvLevel),-1,-1,1,"kEnvAll=4",0,(char*)NULL);
   G__memvar_setup((void*)(&gEnv),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TEnv),-1,-1,1,"gEnv=",0,(char*)NULL);
   G__memvar_setup((void*)(&kInfo),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kInfo=",0,(char*)NULL);
   G__memvar_setup((void*)(&kWarning),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kWarning=",0,(char*)NULL);
   G__memvar_setup((void*)(&kError),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kError=",0,(char*)NULL);
   G__memvar_setup((void*)(&kSysError),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kSysError=",0,(char*)NULL);
   G__memvar_setup((void*)(&kFatal),105,0,1,-1,G__defined_typename("Int_t"),-1,1,"kFatal=",0,(char*)NULL);
   G__memvar_setup((void*)(&gErrorIgnoreLevel),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"gErrorIgnoreLevel=",0,(char*)NULL);
   G__memvar_setup((void*)(&gErrorAbortLevel),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"gErrorAbortLevel=",0,(char*)NULL);
   G__memvar_setup((void*)(&gPrintViaErrorHandler),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"gPrintViaErrorHandler=",0,(char*)NULL);
   G__memvar_setup((void*)(&gPluginMgr),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TPluginManager),-1,-1,1,"gPluginMgr=",0,(char*)NULL);
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)(&gRootDir),67,0,1,-1,-1,-1,1,"gRootDir=",0,(char*)NULL);
   G__memvar_setup((void*)(&gProgName),67,0,1,-1,-1,-1,1,"gProgName=",0,(char*)NULL);
   G__memvar_setup((void*)(&gProgPath),67,0,1,-1,-1,-1,1,"gProgPath=",0,(char*)NULL);
   G__memvar_setup((void*)(&gSystem),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TSystem),-1,-1,1,"gSystem=",0,(char*)NULL);
   G__memvar_setup((void*)(&gROOT),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TROOT),-1,-1,1,"gROOT=",0,(char*)NULL);
   G__memvar_setup((void*)(&gStyle),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TStyle),-1,-1,1,"gStyle=",0,(char*)NULL);
}

static void G__cpp_setup_global5() {
}

static void G__cpp_setup_global6() {
}

static void G__cpp_setup_global7() {
}

static void G__cpp_setup_global8() {
}

static void G__cpp_setup_global9() {
   G__memvar_setup((void*)(&gVirtualPS),85,0,0,G__get_linked_tagnum(&G__G__Base1LN_TVirtualPS),-1,-1,1,"gVirtualPS=",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Base1() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
  G__cpp_setup_global7();
  G__cpp_setup_global8();
  G__cpp_setup_global9();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
   G__memfunc_setup("operator+", 919, G__G__Base1__0_282, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s1 u 'TString' - 11 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_283, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s C - - 10 - cs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_284, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"C - - 10 - cs u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_285, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s c - - 0 - c", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_286, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s l - 'Long_t' 0 - i", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_287, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s k - 'ULong_t' 0 - i", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_290, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"c - - 0 - c u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_291, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - i u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base1__0_292, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - i u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base1__0_295, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s1 u 'TString' - 11 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base1__0_296, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s1 C - - 10 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>>", 1000, G__G__Base1__0_301, 117, G__get_linked_tagnum(&G__G__Base1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - str u 'TString' - 1 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<<", 996, G__G__Base1__0_302, 117, G__get_linked_tagnum(&G__G__Base1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - str u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ToLower", 716, G__G__Base1__0_304, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func3() {
   G__memfunc_setup("ToUpper", 719, G__G__Base1__0_305, 117, G__get_linked_tagnum(&G__G__Base1LN_TString), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Hash", 388, G__G__Base1__0_306, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Hash", 388, G__G__Base1__0_307, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "U 'TString' - 10 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Hash", 388, G__G__Base1__0_308, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "C - - 10 - s", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Form", 404, G__G__Base1__0_309, 67, -1, -1, 0, 1, 8, 1, 0, "C - - 10 - fmt", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Printf", 627, G__G__Base1__0_310, 121, -1, -1, 0, 1, 8, 1, 0, "C - - 10 - fmt", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Strip", 530, G__G__Base1__0_311, 67, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - str c - - 0 '' '' c", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("StrDup", 610, G__G__Base1__0_312, 67, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - str", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Compress", 844, G__G__Base1__0_313, 67, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - str", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("EscChar", 665, G__G__Base1__0_314, 105, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - src C - - 0 - dst "
"i - - 0 - dstlen C - - 0 - specchars "
"c - - 0 - escchar", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("UnEscChar", 860, G__G__Base1__0_315, 105, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - src C - - 0 - dst "
"i - - 0 - dstlen C - - 0 - specchars "
"c - - 0 - escchar", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base1__0_316, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s1 u 'TString' - 11 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base1__0_326, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - s1 u 'TString' - 11 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base1__0_327, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - s1 u 'TString' - 11 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base1__0_344, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TDatime' - 11 - d1 u 'TDatime' - 11 - d2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base1__0_345, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TDatime' - 11 - d1 u 'TDatime' - 11 - d2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base1__0_346, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TDatime' - 11 - d1 u 'TDatime' - 11 - d2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base1__0_347, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TDatime' - 11 - d1 u 'TDatime' - 11 - d2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base1__0_348, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TDatime' - 11 - d1 u 'TDatime' - 11 - d2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base1__0_349, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TDatime' - 11 - d1 u 'TDatime' - 11 - d2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Info", 396, G__G__Base1__0_358, 121, -1, -1, 0, 2, 8, 1, 0, 
"C - - 10 - location C - - 10 - msgfmt", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Warning", 726, G__G__Base1__0_359, 121, -1, -1, 0, 2, 8, 1, 0, 
"C - - 10 - location C - - 10 - msgfmt", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Error", 522, G__G__Base1__0_360, 121, -1, -1, 0, 2, 8, 1, 0, 
"C - - 10 - location C - - 10 - msgfmt", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("SysError", 841, G__G__Base1__0_362, 121, -1, -1, 0, 2, 8, 1, 0, 
"C - - 10 - location C - - 10 - msgfmt", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Fatal", 488, G__G__Base1__0_363, 121, -1, -1, 0, 2, 8, 1, 0, 
"C - - 10 - location C - - 10 - msgfmt", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Base1() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Base1LN_type_info = { "type_info" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TRootIOCtor = { "TRootIOCtor" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_EColor = { "EColor" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TMemberStreamer = { "TMemberStreamer" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualIsAProxy = { "TVirtualIsAProxy" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__Base1LN_ROOTcLcLTInitBehavior = { "ROOT::TInitBehavior" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ofstream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TMethod = { "TMethod" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_EObjBits = { "EObjBits" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualStreamerInfo = { "TVirtualStreamerInfo" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TStreamerElement = { "TStreamerElement" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TProcessID = { "TProcessID" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TRefTable = { "TRefTable" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualArray = { "TVirtualArray" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TStreamerInfoActions = { "TStreamerInfoActions" , 110 , -1 };
G__linked_taginfo G__G__Base1LN_TStreamerInfoActionscLcLTActionSequence = { "TStreamerInfoActions::TActionSequence" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBuffercLcLEMode = { "TBuffer::EMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TBuffercLcLdA = { "TBuffer::$" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGWin32Command = { "TGWin32Command" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TApplicationImp = { "TApplicationImp" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TSignalHandler = { "TSignalHandler" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TApplication = { "TApplication" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TApplicationcLcLEStatusBits = { "TApplication::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TApplicationcLcLEExitOnException = { "TApplication::EExitOnException" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TAttAxis = { "TAttAxis" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TAttBBox = { "TAttBBox" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_ELineStyle = { "ELineStyle" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_EMarkerStyle = { "EMarkerStyle" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TAttPad = { "TAttPad" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TAttText = { "TAttText" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBenchmark = { "TBenchmark" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBrowserImp = { "TBrowserImp" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TContextMenu = { "TContextMenu" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBrowserTimer = { "TBrowserTimer" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBrowsercLcLdA = { "TBrowser::$" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TBuffer3D = { "TBuffer3D" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBuffer3DcLcLEBoolOpCode = { "TBuffer3D::EBoolOpCode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TBuffer3DcLcLESection = { "TBuffer3D::ESection" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TCanvasImp = { "TCanvasImp" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TColor = { "TColor" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TFunction = { "TFunction" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TContextMenuImp = { "TContextMenuImp" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TMethodArg = { "TMethodArg" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TToggle = { "TToggle" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TClassMenuItem = { "TClassMenuItem" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TControlBar = { "TControlBar" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TControlBarButton = { "TControlBarButton" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TControlBarImp = { "TControlBarImp" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TDatime = { "TDatime" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TUUID = { "TUUID" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TKey = { "TKey" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TDirectorycLcLTContext = { "TDirectory::TContext" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TEnv = { "TEnv" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_EEnvLevel = { "EEnvLevel" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TEnvRec = { "TEnvRec" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TInspectorImp = { "TInspectorImp" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGuiFactory = { "TGuiFactory" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TPluginManager = { "TPluginManager" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TPoint = { "TPoint" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_ROOTcLcLTQObjectInitBehavior = { "ROOT::TQObjectInitBehavior" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TSystem = { "TSystem" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TSysEvtHandler = { "TSysEvtHandler" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TFileHandler = { "TFileHandler" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TFileHandlercLcLdA = { "TFileHandler::$" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TStyle = { "TStyle" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TROOT = { "TROOT" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TStylecLcLEPaperSize = { "TStyle::EPaperSize" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TComplex = { "TComplex" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualFFT = { "TVirtualFFT" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_EGEventType = { "EGEventType" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_SetWindowAttributes_t = { "SetWindowAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_WindowAttributes_t = { "WindowAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_EMouseButton = { "EMouseButton" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_GCValues_t = { "GCValues_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_ColorStruct_t = { "ColorStruct_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_PictureAttributes_t = { "PictureAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_EInitialState = { "EInitialState" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_Segment_t = { "Segment_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_Point_t = { "Point_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_Rectangle_t = { "Rectangle_t" , 115 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualViewer3D = { "TVirtualViewer3D" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLCamera = { "TGLCamera" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLBoundingBox = { "TGLBoundingBox" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLRect = { "TGLRect" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualGLPainter = { "TVirtualGLPainter" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualGLManip = { "TVirtualGLManip" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLManager = { "TGLManager" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLContext = { "TGLContext" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLFormat = { "TGLFormat" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TGLPaintDevice = { "TGLPaintDevice" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualPadEditor = { "TVirtualPadEditor" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_ECursor = { "ECursor" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualX = { "TVirtualX" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualXcLcLEDrawMode = { "TVirtualX::EDrawMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualXcLcLEBoxMode = { "TVirtualX::EBoxMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualXcLcLETextMode = { "TVirtualX::ETextMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualXcLcLETextSetMode = { "TVirtualX::ETextSetMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TAxis = { "TAxis" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TView = { "TView" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TFrame = { "TFrame" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TBox = { "TBox" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualPadPainter = { "TVirtualPadPainter" , 99 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualPadPaintercLcLEBoxMode = { "TVirtualPadPainter::EBoxMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualPadPaintercLcLETextMode = { "TVirtualPadPainter::ETextMode" , 101 , -1 };
G__linked_taginfo G__G__Base1LN_TVirtualPS = { "TVirtualPS" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Base1() {
  G__G__Base1LN_type_info.tagnum = -1 ;
  G__G__Base1LN_TClass.tagnum = -1 ;
  G__G__Base1LN_TBuffer.tagnum = -1 ;
  G__G__Base1LN_TDirectory.tagnum = -1 ;
  G__G__Base1LN_TMemberInspector.tagnum = -1 ;
  G__G__Base1LN_TObject.tagnum = -1 ;
  G__G__Base1LN_TNamed.tagnum = -1 ;
  G__G__Base1LN_TRootIOCtor.tagnum = -1 ;
  G__G__Base1LN_TString.tagnum = -1 ;
  G__G__Base1LN_EColor.tagnum = -1 ;
  G__G__Base1LN_TMemberStreamer.tagnum = -1 ;
  G__G__Base1LN_TVirtualIsAProxy.tagnum = -1 ;
  G__G__Base1LN_ROOT.tagnum = -1 ;
  G__G__Base1LN_ROOTcLcLTInitBehavior.tagnum = -1 ;
  G__G__Base1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Base1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Base1LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Base1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Base1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base1LN_TList.tagnum = -1 ;
  G__G__Base1LN_TBrowser.tagnum = -1 ;
  G__G__Base1LN_TObjArray.tagnum = -1 ;
  G__G__Base1LN_TMethod.tagnum = -1 ;
  G__G__Base1LN_TTimer.tagnum = -1 ;
  G__G__Base1LN_EObjBits.tagnum = -1 ;
  G__G__Base1LN_TVirtualStreamerInfo.tagnum = -1 ;
  G__G__Base1LN_TStreamerElement.tagnum = -1 ;
  G__G__Base1LN_TProcessID.tagnum = -1 ;
  G__G__Base1LN_TClonesArray.tagnum = -1 ;
  G__G__Base1LN_TRefTable.tagnum = -1 ;
  G__G__Base1LN_TVirtualArray.tagnum = -1 ;
  G__G__Base1LN_TStreamerInfoActions.tagnum = -1 ;
  G__G__Base1LN_TStreamerInfoActionscLcLTActionSequence.tagnum = -1 ;
  G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Base1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base1LN_TBuffercLcLEMode.tagnum = -1 ;
  G__G__Base1LN_TBuffercLcLdA.tagnum = -1 ;
  G__G__Base1LN_TQObject.tagnum = -1 ;
  G__G__Base1LN_TGWin32Command.tagnum = -1 ;
  G__G__Base1LN_TApplicationImp.tagnum = -1 ;
  G__G__Base1LN_TSignalHandler.tagnum = -1 ;
  G__G__Base1LN_TApplication.tagnum = -1 ;
  G__G__Base1LN_TApplicationcLcLEStatusBits.tagnum = -1 ;
  G__G__Base1LN_TApplicationcLcLEExitOnException.tagnum = -1 ;
  G__G__Base1LN_TAtt3D.tagnum = -1 ;
  G__G__Base1LN_TAttAxis.tagnum = -1 ;
  G__G__Base1LN_TAttBBox.tagnum = -1 ;
  G__G__Base1LN_TAttFill.tagnum = -1 ;
  G__G__Base1LN_TAttLine.tagnum = -1 ;
  G__G__Base1LN_ELineStyle.tagnum = -1 ;
  G__G__Base1LN_TAttMarker.tagnum = -1 ;
  G__G__Base1LN_EMarkerStyle.tagnum = -1 ;
  G__G__Base1LN_TAttPad.tagnum = -1 ;
  G__G__Base1LN_TAttText.tagnum = -1 ;
  G__G__Base1LN_TStopwatch.tagnum = -1 ;
  G__G__Base1LN_TBenchmark.tagnum = -1 ;
  G__G__Base1LN_TGMainFrame.tagnum = -1 ;
  G__G__Base1LN_TBrowserImp.tagnum = -1 ;
  G__G__Base1LN_TContextMenu.tagnum = -1 ;
  G__G__Base1LN_TBrowserTimer.tagnum = -1 ;
  G__G__Base1LN_TBrowsercLcLdA.tagnum = -1 ;
  G__G__Base1LN_TBuffer3D.tagnum = -1 ;
  G__G__Base1LN_TBuffer3DcLcLEBoolOpCode.tagnum = -1 ;
  G__G__Base1LN_TBuffer3DcLcLESection.tagnum = -1 ;
  G__G__Base1LN_TCanvas.tagnum = -1 ;
  G__G__Base1LN_TCanvasImp.tagnum = -1 ;
  G__G__Base1LN_TArrayI.tagnum = -1 ;
  G__G__Base1LN_TColor.tagnum = -1 ;
  G__G__Base1LN_TFunction.tagnum = -1 ;
  G__G__Base1LN_TContextMenuImp.tagnum = -1 ;
  G__G__Base1LN_TMethodArg.tagnum = -1 ;
  G__G__Base1LN_TVirtualPad.tagnum = -1 ;
  G__G__Base1LN_TToggle.tagnum = -1 ;
  G__G__Base1LN_TClassMenuItem.tagnum = -1 ;
  G__G__Base1LN_TControlBar.tagnum = -1 ;
  G__G__Base1LN_TControlBarButton.tagnum = -1 ;
  G__G__Base1LN_TControlBarImp.tagnum = -1 ;
  G__G__Base1LN_TDatime.tagnum = -1 ;
  G__G__Base1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Base1LN_TFile.tagnum = -1 ;
  G__G__Base1LN_TUUID.tagnum = -1 ;
  G__G__Base1LN_TKey.tagnum = -1 ;
  G__G__Base1LN_TDirectorycLcLTContext.tagnum = -1 ;
  G__G__Base1LN_THashList.tagnum = -1 ;
  G__G__Base1LN_TEnv.tagnum = -1 ;
  G__G__Base1LN_EEnvLevel.tagnum = -1 ;
  G__G__Base1LN_TEnvRec.tagnum = -1 ;
  G__G__Base1LN_TInspectorImp.tagnum = -1 ;
  G__G__Base1LN_TGuiFactory.tagnum = -1 ;
  G__G__Base1LN_TPluginManager.tagnum = -1 ;
  G__G__Base1LN_TPoint.tagnum = -1 ;
  G__G__Base1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__Base1LN_ROOTcLcLTQObjectInitBehavior.tagnum = -1 ;
  G__G__Base1LN_TSystem.tagnum = -1 ;
  G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__Base1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base1LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__Base1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base1LN_TSysEvtHandler.tagnum = -1 ;
  G__G__Base1LN_TFileHandler.tagnum = -1 ;
  G__G__Base1LN_TFileHandlercLcLdA.tagnum = -1 ;
  G__G__Base1LN_TStyle.tagnum = -1 ;
  G__G__Base1LN_TROOT.tagnum = -1 ;
  G__G__Base1LN_TStylecLcLEPaperSize.tagnum = -1 ;
  G__G__Base1LN_TComplex.tagnum = -1 ;
  G__G__Base1LN_TVirtualFFT.tagnum = -1 ;
  G__G__Base1LN_EGEventType.tagnum = -1 ;
  G__G__Base1LN_SetWindowAttributes_t.tagnum = -1 ;
  G__G__Base1LN_WindowAttributes_t.tagnum = -1 ;
  G__G__Base1LN_Event_t.tagnum = -1 ;
  G__G__Base1LN_EMouseButton.tagnum = -1 ;
  G__G__Base1LN_GCValues_t.tagnum = -1 ;
  G__G__Base1LN_ColorStruct_t.tagnum = -1 ;
  G__G__Base1LN_PictureAttributes_t.tagnum = -1 ;
  G__G__Base1LN_EInitialState.tagnum = -1 ;
  G__G__Base1LN_Segment_t.tagnum = -1 ;
  G__G__Base1LN_Point_t.tagnum = -1 ;
  G__G__Base1LN_Rectangle_t.tagnum = -1 ;
  G__G__Base1LN_TVirtualViewer3D.tagnum = -1 ;
  G__G__Base1LN_TGLCamera.tagnum = -1 ;
  G__G__Base1LN_TGLBoundingBox.tagnum = -1 ;
  G__G__Base1LN_TGLRect.tagnum = -1 ;
  G__G__Base1LN_TVirtualGLPainter.tagnum = -1 ;
  G__G__Base1LN_TVirtualGLManip.tagnum = -1 ;
  G__G__Base1LN_TGLManager.tagnum = -1 ;
  G__G__Base1LN_TGLContext.tagnum = -1 ;
  G__G__Base1LN_TGLFormat.tagnum = -1 ;
  G__G__Base1LN_TGLPaintDevice.tagnum = -1 ;
  G__G__Base1LN_TVirtualPadEditor.tagnum = -1 ;
  G__G__Base1LN_ECursor.tagnum = -1 ;
  G__G__Base1LN_TVirtualX.tagnum = -1 ;
  G__G__Base1LN_TVirtualXcLcLEDrawMode.tagnum = -1 ;
  G__G__Base1LN_TVirtualXcLcLEBoxMode.tagnum = -1 ;
  G__G__Base1LN_TVirtualXcLcLETextMode.tagnum = -1 ;
  G__G__Base1LN_TVirtualXcLcLETextSetMode.tagnum = -1 ;
  G__G__Base1LN_TAxis.tagnum = -1 ;
  G__G__Base1LN_TView.tagnum = -1 ;
  G__G__Base1LN_TH1F.tagnum = -1 ;
  G__G__Base1LN_TFrame.tagnum = -1 ;
  G__G__Base1LN_TBox.tagnum = -1 ;
  G__G__Base1LN_TVirtualPadPainter.tagnum = -1 ;
  G__G__Base1LN_TVirtualPadPaintercLcLEBoxMode.tagnum = -1 ;
  G__G__Base1LN_TVirtualPadPaintercLcLETextMode.tagnum = -1 ;
  G__G__Base1LN_TVirtualPS.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Base1() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Base1LN_type_info);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TClass);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TBuffer),sizeof(TBuffer),-1,65205,"Buffer base class used for serializing objects",G__setup_memvarTBuffer,G__setup_memfuncTBuffer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TDirectory),sizeof(TDirectory),-1,65280,"Describe directory structure in memory",G__setup_memvarTDirectory,G__setup_memfuncTDirectory);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TNamed);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TRootIOCtor),sizeof(TRootIOCtor),-1,262144,(char*)NULL,G__setup_memvarTRootIOCtor,G__setup_memfuncTRootIOCtor);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_EColor),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TMemberStreamer);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualIsAProxy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_ROOT),0,-1,0,(char*)NULL,G__setup_memvarROOT,G__setup_memfuncROOT);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_ROOTcLcLTInitBehavior);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TBrowser),sizeof(TBrowser),-1,327424,"ROOT Object Browser",G__setup_memvarTBrowser,G__setup_memfuncTBrowser);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TMethod);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_EObjBits),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualStreamerInfo);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TStreamerElement);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TProcessID);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TClonesArray);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TRefTable);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualArray);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TStreamerInfoActions);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TStreamerInfoActionscLcLTActionSequence);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBuffercLcLEMode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBuffercLcLdA);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGWin32Command);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TApplicationImp),sizeof(TApplicationImp),-1,34048,"ABC describing application protocol",G__setup_memvarTApplicationImp,G__setup_memfuncTApplicationImp);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TSignalHandler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TApplication),sizeof(TApplication),-1,65280,"GUI application singleton",G__setup_memvarTApplication,G__setup_memfuncTApplication);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TApplicationcLcLEStatusBits);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TApplicationcLcLEExitOnException);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAtt3D),sizeof(TAtt3D),-1,263424,"3D attributes",G__setup_memvarTAtt3D,G__setup_memfuncTAtt3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttAxis),sizeof(TAttAxis),-1,66816,"Axis attributes",G__setup_memvarTAttAxis,G__setup_memfuncTAttAxis);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttBBox),sizeof(TAttBBox),-1,265985,"Helper for management of bounding-box information",G__setup_memvarTAttBBox,G__setup_memfuncTAttBBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttFill),sizeof(TAttFill),-1,296192,"Fill area attributes",G__setup_memvarTAttFill,G__setup_memfuncTAttFill);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttLine),sizeof(TAttLine),-1,296192,"Line attributes",G__setup_memvarTAttLine,G__setup_memfuncTAttLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_ELineStyle),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttMarker),sizeof(TAttMarker),-1,296192,"Marker attributes",G__setup_memvarTAttMarker,G__setup_memfuncTAttMarker);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_EMarkerStyle),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttPad),sizeof(TAttPad),-1,66816,"Pad attributes",G__setup_memvarTAttPad,G__setup_memfuncTAttPad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TAttText),sizeof(TAttText),-1,296192,"Text attributes",G__setup_memvarTAttText,G__setup_memfuncTAttText);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TStopwatch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TBenchmark),sizeof(TBenchmark),-1,327424,"ROOT utility to help benchmarking applications",G__setup_memvarTBenchmark,G__setup_memfuncTBenchmark);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGMainFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TBrowserImp),sizeof(TBrowserImp),-1,298752,"ABC describing browser implementation protocol",G__setup_memvarTBrowserImp,G__setup_memfuncTBrowserImp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TContextMenu),sizeof(TContextMenu),-1,327424,"Context sensitive popup menu",G__setup_memvarTContextMenu,G__setup_memfuncTContextMenu);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBrowserTimer);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBrowsercLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TBuffer3D),sizeof(TBuffer3D),-1,65024,"3D primitives description",G__setup_memvarTBuffer3D,G__setup_memfuncTBuffer3D);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBuffer3DcLcLEBoolOpCode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBuffer3DcLcLESection);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TCanvas);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TCanvasImp),sizeof(TCanvasImp),-1,36608,"ABC describing main window protocol",G__setup_memvarTCanvasImp,G__setup_memfuncTCanvasImp);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TArrayI);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TColor),sizeof(TColor),-1,325376,"Color defined by RGB or HLS",G__setup_memvarTColor,G__setup_memfuncTColor);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TFunction);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TContextMenuImp),sizeof(TContextMenuImp),-1,265984,"Context sensitive popup menu implementation",G__setup_memvarTContextMenuImp,G__setup_memfuncTContextMenuImp);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TMethodArg);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualPad),sizeof(TVirtualPad),-1,128172,"Abstract base class for Pads and Canvases",G__setup_memvarTVirtualPad,G__setup_memfuncTVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TToggle);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TClassMenuItem);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TControlBar);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TControlBarButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TControlBarImp),sizeof(TControlBarImp),-1,295936,"GUI independent controlbar abc",G__setup_memvarTControlBarImp,G__setup_memfuncTControlBarImp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TDatime),sizeof(TDatime),-1,102144,"Date and time 950130 124559",G__setup_memvarTDatime,G__setup_memfuncTDatime);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TFile);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TUUID);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TKey);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TDirectorycLcLTContext);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_THashList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TEnv),sizeof(TEnv),-1,294656,"Handle ROOT configuration resources",G__setup_memvarTEnv,G__setup_memfuncTEnv);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_EEnvLevel),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TEnvRec),sizeof(TEnvRec),-1,323840,"Individual TEnv records",G__setup_memvarTEnvRec,G__setup_memfuncTEnvRec);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TInspectorImp),sizeof(TInspectorImp),-1,296192,"GUI independent inspector abc",G__setup_memvarTInspectorImp,G__setup_memfuncTInspectorImp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TGuiFactory),sizeof(TGuiFactory),-1,62720,"Abstract factory for GUI components",G__setup_memvarTGuiFactory,G__setup_memfuncTGuiFactory);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TPluginManager);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TPoint);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_ROOTcLcLTQObjectInitBehavior);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TSystem);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TSysEvtHandler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TFileHandler),sizeof(TFileHandler),-1,324864,"Handles events on file descriptors",G__setup_memvarTFileHandler,G__setup_memfuncTFileHandler);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TFileHandlercLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TStyle),sizeof(TStyle),-1,325376,"A collection of all graphics attributes",G__setup_memvarTStyle,G__setup_memfuncTStyle);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TROOT);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TStylecLcLEPaperSize);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TComplex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualFFT),sizeof(TVirtualFFT),-1,29973,"abstract interface for FFT calculations",G__setup_memvarTVirtualFFT,G__setup_memfuncTVirtualFFT);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_EGEventType);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_SetWindowAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_WindowAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_EMouseButton);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_GCValues_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_ColorStruct_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_PictureAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_EInitialState);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_Segment_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_Point_t);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_Rectangle_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualViewer3D),sizeof(TVirtualViewer3D),-1,29705,"Abstract interface to 3D viewers",G__setup_memvarTVirtualViewer3D,G__setup_memfuncTVirtualViewer3D);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLCamera);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLBoundingBox);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLRect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualGLPainter),sizeof(TVirtualGLPainter),-1,1028,"Interface for OpenGL painter",G__setup_memvarTVirtualGLPainter,G__setup_memfuncTVirtualGLPainter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualGLManip),sizeof(TVirtualGLManip),-1,1025,"Interface for GL manipulator",G__setup_memvarTVirtualGLManip,G__setup_memfuncTVirtualGLManip);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLManager),sizeof(TGLManager),-1,64275,"Interface for OpenGL manager",G__setup_memvarTGLManager,G__setup_memfuncTGLManager);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLContext);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLFormat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TGLPaintDevice),sizeof(TGLPaintDevice),-1,1031,"Base class for GL widgets and GL off-screen rendering",G__setup_memvarTGLPaintDevice,G__setup_memfuncTGLPaintDevice);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualPadEditor),sizeof(TVirtualPadEditor),-1,1282,"Abstract interface for graphics pad editor",G__setup_memvarTVirtualPadEditor,G__setup_memfuncTVirtualPadEditor);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_ECursor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualX),sizeof(TVirtualX),-1,324864,"ABC defining a generic interface to graphics system",G__setup_memvarTVirtualX,G__setup_memfuncTVirtualX);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualXcLcLEDrawMode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualXcLcLEBoxMode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualXcLcLETextMode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualXcLcLETextSetMode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TAxis);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TView);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TH1F);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TFrame);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualPadPainter),sizeof(TVirtualPadPainter),-1,1066,"Painter interface for pad.",G__setup_memvarTVirtualPadPainter,G__setup_memfuncTVirtualPadPainter);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualPadPaintercLcLEBoxMode);
   G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualPadPaintercLcLETextMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base1LN_TVirtualPS),sizeof(TVirtualPS),-1,65294,"Abstract interface to a PostScript driver",G__setup_memvarTVirtualPS,G__setup_memfuncTVirtualPS);
}
extern "C" void G__cpp_setupG__Base1(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Base1()");
  G__set_cpp_environmentG__Base1();
  G__cpp_setup_tagtableG__Base1();

  G__cpp_setup_inheritanceG__Base1();

  G__cpp_setup_typetableG__Base1();

  G__cpp_setup_memvarG__Base1();

  G__cpp_setup_memfuncG__Base1();
  G__cpp_setup_globalG__Base1();
  G__cpp_setup_funcG__Base1();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Base1();
  return;
}
class G__cpp_setup_initG__Base1 {
  public:
    G__cpp_setup_initG__Base1() { G__add_setup_func("G__Base1",(G__incsetup)(&G__cpp_setupG__Base1)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Base1() { G__remove_setup_func("G__Base1"); }
};
G__cpp_setup_initG__Base1 G__cpp_setup_initializerG__Base1;

---