G__Gui3.cxx

Go to the documentation of this file.

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

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

#define R__DICTIONARY_FILENAME guidIguidIsrcdIG__Gui3
#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__Gui3.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void TRootGuiFactory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootGuiFactory(void *p = 0);
   static void *newArray_TRootGuiFactory(Long_t size, void *p);
   static void delete_TRootGuiFactory(void *p);
   static void deleteArray_TRootGuiFactory(void *p);
   static void destruct_TRootGuiFactory(void *p);
   static void streamer_TRootGuiFactory(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootApplication_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TRootApplication(void *p);
   static void deleteArray_TRootApplication(void *p);
   static void destruct_TRootApplication(void *p);
   static void streamer_TRootApplication(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDNDData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDNDData(void *p = 0);
   static void *newArray_TDNDData(Long_t size, void *p);
   static void delete_TDNDData(void *p);
   static void deleteArray_TDNDData(void *p);
   static void destruct_TDNDData(void *p);
   static void streamer_TDNDData(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDNDData*)
   {
      ::TDNDData *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDNDData >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDNDData", ::TDNDData::Class_Version(), "include/TGDNDManager.h", 67,
                  typeid(::TDNDData), DefineBehavior(ptr, ptr),
                  &::TDNDData::Dictionary, isa_proxy, 0,
                  sizeof(::TDNDData) );
      instance.SetNew(&new_TDNDData);
      instance.SetNewArray(&newArray_TDNDData);
      instance.SetDelete(&delete_TDNDData);
      instance.SetDeleteArray(&deleteArray_TDNDData);
      instance.SetDestructor(&destruct_TDNDData);
      instance.SetStreamerFunc(&streamer_TDNDData);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDNDData*)
   {
      return GenerateInitInstanceLocal((::TDNDData*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDNDData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGDockableFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGDockableFrame(void *p = 0);
   static void *newArray_TGDockableFrame(Long_t size, void *p);
   static void delete_TGDockableFrame(void *p);
   static void deleteArray_TGDockableFrame(void *p);
   static void destruct_TGDockableFrame(void *p);
   static void streamer_TGDockableFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGDNDManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGDNDManager(void *p);
   static void deleteArray_TGDNDManager(void *p);
   static void destruct_TGDNDManager(void *p);
   static void streamer_TGDNDManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootCanvas_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootCanvas(void *p = 0);
   static void *newArray_TRootCanvas(Long_t size, void *p);
   static void delete_TRootCanvas(void *p);
   static void deleteArray_TRootCanvas(void *p);
   static void destruct_TRootCanvas(void *p);
   static void streamer_TRootCanvas(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootBrowserLite_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootBrowserLite(void *p = 0);
   static void *newArray_TRootBrowserLite(Long_t size, void *p);
   static void delete_TRootBrowserLite(void *p);
   static void deleteArray_TRootBrowserLite(void *p);
   static void destruct_TRootBrowserLite(void *p);
   static void streamer_TRootBrowserLite(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRootBrowserLite*)
   {
      ::TRootBrowserLite *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRootBrowserLite >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRootBrowserLite", ::TRootBrowserLite::Class_Version(), "include/TRootBrowserLite.h", 52,
                  typeid(::TRootBrowserLite), DefineBehavior(ptr, ptr),
                  &::TRootBrowserLite::Dictionary, isa_proxy, 0,
                  sizeof(::TRootBrowserLite) );
      instance.SetNew(&new_TRootBrowserLite);
      instance.SetNewArray(&newArray_TRootBrowserLite);
      instance.SetDelete(&delete_TRootBrowserLite);
      instance.SetDeleteArray(&deleteArray_TRootBrowserLite);
      instance.SetDestructor(&destruct_TRootBrowserLite);
      instance.SetStreamerFunc(&streamer_TRootBrowserLite);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRootBrowserLite*)
   {
      return GenerateInitInstanceLocal((::TRootBrowserLite*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRootBrowserLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRootDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootDialog(void *p = 0);
   static void *newArray_TRootDialog(Long_t size, void *p);
   static void delete_TRootDialog(void *p);
   static void deleteArray_TRootDialog(void *p);
   static void destruct_TRootDialog(void *p);
   static void streamer_TRootDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootContextMenu_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootContextMenu(void *p = 0);
   static void *newArray_TRootContextMenu(Long_t size, void *p);
   static void delete_TRootContextMenu(void *p);
   static void deleteArray_TRootContextMenu(void *p);
   static void destruct_TRootContextMenu(void *p);
   static void streamer_TRootContextMenu(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootControlBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootControlBar(void *p = 0);
   static void *newArray_TRootControlBar(Long_t size, void *p);
   static void delete_TRootControlBar(void *p);
   static void deleteArray_TRootControlBar(void *p);
   static void destruct_TRootControlBar(void *p);
   static void streamer_TRootControlBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootHelpDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootHelpDialog(void *p = 0);
   static void *newArray_TRootHelpDialog(Long_t size, void *p);
   static void delete_TRootHelpDialog(void *p);
   static void deleteArray_TRootHelpDialog(void *p);
   static void destruct_TRootHelpDialog(void *p);
   static void streamer_TRootHelpDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootEmbeddedCanvas_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootEmbeddedCanvas(void *p = 0);
   static void *newArray_TRootEmbeddedCanvas(Long_t size, void *p);
   static void delete_TRootEmbeddedCanvas(void *p);
   static void deleteArray_TRootEmbeddedCanvas(void *p);
   static void destruct_TRootEmbeddedCanvas(void *p);
   static void streamer_TRootEmbeddedCanvas(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGColorPalette_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGColorPalette(void *p = 0);
   static void *newArray_TGColorPalette(Long_t size, void *p);
   static void delete_TGColorPalette(void *p);
   static void deleteArray_TGColorPalette(void *p);
   static void destruct_TGColorPalette(void *p);
   static void streamer_TGColorPalette(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGColorPalette*)
   {
      ::TGColorPalette *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGColorPalette >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGColorPalette", ::TGColorPalette::Class_Version(), "include/TGColorDialog.h", 56,
                  typeid(::TGColorPalette), DefineBehavior(ptr, ptr),
                  &::TGColorPalette::Dictionary, isa_proxy, 0,
                  sizeof(::TGColorPalette) );
      instance.SetNew(&new_TGColorPalette);
      instance.SetNewArray(&newArray_TGColorPalette);
      instance.SetDelete(&delete_TGColorPalette);
      instance.SetDeleteArray(&deleteArray_TGColorPalette);
      instance.SetDestructor(&destruct_TGColorPalette);
      instance.SetStreamerFunc(&streamer_TGColorPalette);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGColorPalette*)
   {
      return GenerateInitInstanceLocal((::TGColorPalette*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGColorPalette*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGColorPick_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGColorPick(void *p = 0);
   static void *newArray_TGColorPick(Long_t size, void *p);
   static void delete_TGColorPick(void *p);
   static void deleteArray_TGColorPick(void *p);
   static void destruct_TGColorPick(void *p);
   static void streamer_TGColorPick(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGColorPick*)
   {
      ::TGColorPick *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGColorPick >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGColorPick", ::TGColorPick::Class_Version(), "include/TGColorDialog.h", 107,
                  typeid(::TGColorPick), DefineBehavior(ptr, ptr),
                  &::TGColorPick::Dictionary, isa_proxy, 0,
                  sizeof(::TGColorPick) );
      instance.SetNew(&new_TGColorPick);
      instance.SetNewArray(&newArray_TGColorPick);
      instance.SetDelete(&delete_TGColorPick);
      instance.SetDeleteArray(&deleteArray_TGColorPick);
      instance.SetDestructor(&destruct_TGColorPick);
      instance.SetStreamerFunc(&streamer_TGColorPick);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGColorPick*)
   {
      return GenerateInitInstanceLocal((::TGColorPick*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGColorPick*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGColorDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGColorDialog(void *p = 0);
   static void *newArray_TGColorDialog(Long_t size, void *p);
   static void delete_TGColorDialog(void *p);
   static void deleteArray_TGColorDialog(void *p);
   static void destruct_TGColorDialog(void *p);
   static void streamer_TGColorDialog(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGColorDialog*)
   {
      ::TGColorDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGColorDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGColorDialog", ::TGColorDialog::Class_Version(), "include/TGColorDialog.h", 160,
                  typeid(::TGColorDialog), DefineBehavior(ptr, ptr),
                  &::TGColorDialog::Dictionary, isa_proxy, 0,
                  sizeof(::TGColorDialog) );
      instance.SetNew(&new_TGColorDialog);
      instance.SetNewArray(&newArray_TGColorDialog);
      instance.SetDelete(&delete_TGColorDialog);
      instance.SetDeleteArray(&deleteArray_TGColorDialog);
      instance.SetDestructor(&destruct_TGColorDialog);
      instance.SetStreamerFunc(&streamer_TGColorDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGColorDialog*)
   {
      return GenerateInitInstanceLocal((::TGColorDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGColorDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGColorFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGColorFrame(void *p = 0);
   static void *newArray_TGColorFrame(Long_t size, void *p);
   static void delete_TGColorFrame(void *p);
   static void deleteArray_TGColorFrame(void *p);
   static void destruct_TGColorFrame(void *p);
   static void streamer_TGColorFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGColorFrame*)
   {
      ::TGColorFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGColorFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGColorFrame", ::TGColorFrame::Class_Version(), "include/TGColorSelect.h", 49,
                  typeid(::TGColorFrame), DefineBehavior(ptr, ptr),
                  &::TGColorFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGColorFrame) );
      instance.SetNew(&new_TGColorFrame);
      instance.SetNewArray(&newArray_TGColorFrame);
      instance.SetDelete(&delete_TGColorFrame);
      instance.SetDeleteArray(&deleteArray_TGColorFrame);
      instance.SetDestructor(&destruct_TGColorFrame);
      instance.SetStreamerFunc(&streamer_TGColorFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGColorFrame*)
   {
      return GenerateInitInstanceLocal((::TGColorFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGColorFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TG16ColorSelector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TG16ColorSelector(void *p = 0);
   static void *newArray_TG16ColorSelector(Long_t size, void *p);
   static void delete_TG16ColorSelector(void *p);
   static void deleteArray_TG16ColorSelector(void *p);
   static void destruct_TG16ColorSelector(void *p);
   static void streamer_TG16ColorSelector(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TG16ColorSelector*)
   {
      ::TG16ColorSelector *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TG16ColorSelector >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TG16ColorSelector", ::TG16ColorSelector::Class_Version(), "include/TGColorSelect.h", 77,
                  typeid(::TG16ColorSelector), DefineBehavior(ptr, ptr),
                  &::TG16ColorSelector::Dictionary, isa_proxy, 0,
                  sizeof(::TG16ColorSelector) );
      instance.SetNew(&new_TG16ColorSelector);
      instance.SetNewArray(&newArray_TG16ColorSelector);
      instance.SetDelete(&delete_TG16ColorSelector);
      instance.SetDeleteArray(&deleteArray_TG16ColorSelector);
      instance.SetDestructor(&destruct_TG16ColorSelector);
      instance.SetStreamerFunc(&streamer_TG16ColorSelector);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TG16ColorSelector*)
   {
      return GenerateInitInstanceLocal((::TG16ColorSelector*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TG16ColorSelector*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGColorPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGColorPopup(void *p = 0);
   static void *newArray_TGColorPopup(Long_t size, void *p);
   static void delete_TGColorPopup(void *p);
   static void deleteArray_TGColorPopup(void *p);
   static void destruct_TGColorPopup(void *p);
   static void streamer_TGColorPopup(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGColorPopup*)
   {
      ::TGColorPopup *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGColorPopup >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGColorPopup", ::TGColorPopup::Class_Version(), "include/TGColorSelect.h", 102,
                  typeid(::TGColorPopup), DefineBehavior(ptr, ptr),
                  &::TGColorPopup::Dictionary, isa_proxy, 0,
                  sizeof(::TGColorPopup) );
      instance.SetNew(&new_TGColorPopup);
      instance.SetNewArray(&newArray_TGColorPopup);
      instance.SetDelete(&delete_TGColorPopup);
      instance.SetDeleteArray(&deleteArray_TGColorPopup);
      instance.SetDestructor(&destruct_TGColorPopup);
      instance.SetStreamerFunc(&streamer_TGColorPopup);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGColorPopup*)
   {
      return GenerateInitInstanceLocal((::TGColorPopup*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGColorPopup*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGColorSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGColorSelect(void *p = 0);
   static void *newArray_TGColorSelect(Long_t size, void *p);
   static void delete_TGColorSelect(void *p);
   static void deleteArray_TGColorSelect(void *p);
   static void destruct_TGColorSelect(void *p);
   static void streamer_TGColorSelect(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGColorSelect*)
   {
      ::TGColorSelect *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGColorSelect >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGColorSelect", ::TGColorSelect::Class_Version(), "include/TGColorSelect.h", 130,
                  typeid(::TGColorSelect), DefineBehavior(ptr, ptr),
                  &::TGColorSelect::Dictionary, isa_proxy, 0,
                  sizeof(::TGColorSelect) );
      instance.SetNew(&new_TGColorSelect);
      instance.SetNewArray(&newArray_TGColorSelect);
      instance.SetDelete(&delete_TGColorSelect);
      instance.SetDeleteArray(&deleteArray_TGColorSelect);
      instance.SetDestructor(&destruct_TGColorSelect);
      instance.SetStreamerFunc(&streamer_TGColorSelect);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGColorSelect*)
   {
      return GenerateInitInstanceLocal((::TGColorSelect*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGColorSelect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFontDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFontDialog(void *p = 0);
   static void *newArray_TGFontDialog(Long_t size, void *p);
   static void delete_TGFontDialog(void *p);
   static void deleteArray_TGFontDialog(void *p);
   static void destruct_TGFontDialog(void *p);
   static void streamer_TGFontDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGFontDialogcLcLFontProp_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGFontDialogcLcLFontProp_t_Dictionary();
   static void *new_TGFontDialogcLcLFontProp_t(void *p = 0);
   static void *newArray_TGFontDialogcLcLFontProp_t(Long_t size, void *p);
   static void delete_TGFontDialogcLcLFontProp_t(void *p);
   static void deleteArray_TGFontDialogcLcLFontProp_t(void *p);
   static void destruct_TGFontDialogcLcLFontProp_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFontDialog::FontProp_t*)
   {
      ::TGFontDialog::FontProp_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGFontDialog::FontProp_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFontDialog::FontProp_t", "include/TGFontDialog.h", 41,
                  typeid(::TGFontDialog::FontProp_t), DefineBehavior(ptr, ptr),
                  0, &TGFontDialogcLcLFontProp_t_Dictionary, isa_proxy, 0,
                  sizeof(::TGFontDialog::FontProp_t) );
      instance.SetNew(&new_TGFontDialogcLcLFontProp_t);
      instance.SetNewArray(&newArray_TGFontDialogcLcLFontProp_t);
      instance.SetDelete(&delete_TGFontDialogcLcLFontProp_t);
      instance.SetDeleteArray(&deleteArray_TGFontDialogcLcLFontProp_t);
      instance.SetDestructor(&destruct_TGFontDialogcLcLFontProp_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFontDialog::FontProp_t*)
   {
      return GenerateInitInstanceLocal((::TGFontDialog::FontProp_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFontDialog::FontProp_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGDockButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGDockButton(void *p = 0);
   static void *newArray_TGDockButton(Long_t size, void *p);
   static void delete_TGDockButton(void *p);
   static void deleteArray_TGDockButton(void *p);
   static void destruct_TGDockButton(void *p);
   static void streamer_TGDockButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGDockButton*)
   {
      ::TGDockButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGDockButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGDockButton", ::TGDockButton::Class_Version(), "include/TGDockableFrame.h", 47,
                  typeid(::TGDockButton), DefineBehavior(ptr, ptr),
                  &::TGDockButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGDockButton) );
      instance.SetNew(&new_TGDockButton);
      instance.SetNewArray(&newArray_TGDockButton);
      instance.SetDelete(&delete_TGDockButton);
      instance.SetDeleteArray(&deleteArray_TGDockButton);
      instance.SetDestructor(&destruct_TGDockButton);
      instance.SetStreamerFunc(&streamer_TGDockButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGDockButton*)
   {
      return GenerateInitInstanceLocal((::TGDockButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGDockButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGDockHideButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGDockHideButton(void *p = 0);
   static void *newArray_TGDockHideButton(Long_t size, void *p);
   static void delete_TGDockHideButton(void *p);
   static void deleteArray_TGDockHideButton(void *p);
   static void destruct_TGDockHideButton(void *p);
   static void streamer_TGDockHideButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGDockHideButton*)
   {
      ::TGDockHideButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGDockHideButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGDockHideButton", ::TGDockHideButton::Class_Version(), "include/TGDockableFrame.h", 66,
                  typeid(::TGDockHideButton), DefineBehavior(ptr, ptr),
                  &::TGDockHideButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGDockHideButton) );
      instance.SetNew(&new_TGDockHideButton);
      instance.SetNewArray(&newArray_TGDockHideButton);
      instance.SetDelete(&delete_TGDockHideButton);
      instance.SetDeleteArray(&deleteArray_TGDockHideButton);
      instance.SetDestructor(&destruct_TGDockHideButton);
      instance.SetStreamerFunc(&streamer_TGDockHideButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGDockHideButton*)
   {
      return GenerateInitInstanceLocal((::TGDockHideButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGDockHideButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGUndockedFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGUndockedFrame(void *p = 0);
   static void *newArray_TGUndockedFrame(Long_t size, void *p);
   static void delete_TGUndockedFrame(void *p);
   static void deleteArray_TGUndockedFrame(void *p);
   static void destruct_TGUndockedFrame(void *p);
   static void streamer_TGUndockedFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGUndockedFrame*)
   {
      ::TGUndockedFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGUndockedFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGUndockedFrame", ::TGUndockedFrame::Class_Version(), "include/TGDockableFrame.h", 81,
                  typeid(::TGUndockedFrame), DefineBehavior(ptr, ptr),
                  &::TGUndockedFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGUndockedFrame) );
      instance.SetNew(&new_TGUndockedFrame);
      instance.SetNewArray(&newArray_TGUndockedFrame);
      instance.SetDelete(&delete_TGUndockedFrame);
      instance.SetDeleteArray(&deleteArray_TGUndockedFrame);
      instance.SetDestructor(&destruct_TGUndockedFrame);
      instance.SetStreamerFunc(&streamer_TGUndockedFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGUndockedFrame*)
   {
      return GenerateInitInstanceLocal((::TGUndockedFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGUndockedFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMdiMenuBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiMenuBar(void *p);
   static void deleteArray_TGMdiMenuBar(void *p);
   static void destruct_TGMdiMenuBar(void *p);
   static void streamer_TGMdiMenuBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiContainer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiContainer(void *p);
   static void deleteArray_TGMdiContainer(void *p);
   static void destruct_TGMdiContainer(void *p);
   static void streamer_TGMdiContainer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiDecorFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiDecorFrame(void *p);
   static void deleteArray_TGMdiDecorFrame(void *p);
   static void destruct_TGMdiDecorFrame(void *p);
   static void streamer_TGMdiDecorFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiFrame(void *p);
   static void deleteArray_TGMdiFrame(void *p);
   static void destruct_TGMdiFrame(void *p);
   static void streamer_TGMdiFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiFrameList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMdiFrameList(void *p = 0);
   static void *newArray_TGMdiFrameList(Long_t size, void *p);
   static void delete_TGMdiFrameList(void *p);
   static void deleteArray_TGMdiFrameList(void *p);
   static void destruct_TGMdiFrameList(void *p);
   static void streamer_TGMdiFrameList(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMdiFrameList*)
   {
      ::TGMdiFrameList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMdiFrameList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMdiFrameList", ::TGMdiFrameList::Class_Version(), "include/TGMdiMainFrame.h", 99,
                  typeid(::TGMdiFrameList), DefineBehavior(ptr, ptr),
                  &::TGMdiFrameList::Dictionary, isa_proxy, 0,
                  sizeof(::TGMdiFrameList) );
      instance.SetNew(&new_TGMdiFrameList);
      instance.SetNewArray(&newArray_TGMdiFrameList);
      instance.SetDelete(&delete_TGMdiFrameList);
      instance.SetDeleteArray(&deleteArray_TGMdiFrameList);
      instance.SetDestructor(&destruct_TGMdiFrameList);
      instance.SetStreamerFunc(&streamer_TGMdiFrameList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMdiFrameList*)
   {
      return GenerateInitInstanceLocal((::TGMdiFrameList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMdiFrameList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMdiMainFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiMainFrame(void *p);
   static void deleteArray_TGMdiMainFrame(void *p);
   static void destruct_TGMdiMainFrame(void *p);
   static void streamer_TGMdiMainFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiGeometry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMdiGeometry(void *p = 0);
   static void *newArray_TGMdiGeometry(Long_t size, void *p);
   static void delete_TGMdiGeometry(void *p);
   static void deleteArray_TGMdiGeometry(void *p);
   static void destruct_TGMdiGeometry(void *p);
   static void streamer_TGMdiGeometry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMdiGeometry*)
   {
      ::TGMdiGeometry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMdiGeometry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMdiGeometry", ::TGMdiGeometry::Class_Version(), "include/TGMdiMainFrame.h", 130,
                  typeid(::TGMdiGeometry), DefineBehavior(ptr, ptr),
                  &::TGMdiGeometry::Dictionary, isa_proxy, 0,
                  sizeof(::TGMdiGeometry) );
      instance.SetNew(&new_TGMdiGeometry);
      instance.SetNewArray(&newArray_TGMdiGeometry);
      instance.SetDelete(&delete_TGMdiGeometry);
      instance.SetDeleteArray(&deleteArray_TGMdiGeometry);
      instance.SetDestructor(&destruct_TGMdiGeometry);
      instance.SetStreamerFunc(&streamer_TGMdiGeometry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMdiGeometry*)
   {
      return GenerateInitInstanceLocal((::TGMdiGeometry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMdiGeometry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMdiTitleIcon_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiTitleIcon(void *p);
   static void deleteArray_TGMdiTitleIcon(void *p);
   static void destruct_TGMdiTitleIcon(void *p);
   static void streamer_TGMdiTitleIcon(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiButtons_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiButtons(void *p);
   static void deleteArray_TGMdiButtons(void *p);
   static void destruct_TGMdiButtons(void *p);
   static void streamer_TGMdiButtons(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiTitleBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiTitleBar(void *p);
   static void deleteArray_TGMdiTitleBar(void *p);
   static void destruct_TGMdiTitleBar(void *p);
   static void streamer_TGMdiTitleBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiWinResizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiWinResizer(void *p);
   static void deleteArray_TGMdiWinResizer(void *p);
   static void destruct_TGMdiWinResizer(void *p);
   static void streamer_TGMdiWinResizer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiVerticalWinResizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiVerticalWinResizer(void *p);
   static void deleteArray_TGMdiVerticalWinResizer(void *p);
   static void destruct_TGMdiVerticalWinResizer(void *p);
   static void streamer_TGMdiVerticalWinResizer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiHorizontalWinResizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiHorizontalWinResizer(void *p);
   static void deleteArray_TGMdiHorizontalWinResizer(void *p);
   static void destruct_TGMdiHorizontalWinResizer(void *p);
   static void streamer_TGMdiHorizontalWinResizer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMdiCornerWinResizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMdiCornerWinResizer(void *p);
   static void deleteArray_TGMdiCornerWinResizer(void *p);
   static void destruct_TGMdiCornerWinResizer(void *p);
   static void streamer_TGMdiCornerWinResizer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVirtualDragManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TVirtualDragManager(void *p = 0);
   static void *newArray_TVirtualDragManager(Long_t size, void *p);
   static void delete_TVirtualDragManager(void *p);
   static void deleteArray_TVirtualDragManager(void *p);
   static void destruct_TVirtualDragManager(void *p);
   static void streamer_TVirtualDragManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGuiBldAction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGuiBldAction(void *p = 0);
   static void *newArray_TGuiBldAction(Long_t size, void *p);
   static void delete_TGuiBldAction(void *p);
   static void deleteArray_TGuiBldAction(void *p);
   static void destruct_TGuiBldAction(void *p);
   static void streamer_TGuiBldAction(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGuiBuilder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGuiBuilder(void *p = 0);
   static void *newArray_TGuiBuilder(Long_t size, void *p);
   static void delete_TGuiBuilder(void *p);
   static void deleteArray_TGuiBuilder(void *p);
   static void destruct_TGuiBuilder(void *p);
   static void streamer_TGuiBuilder(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGuiBuilder*)
   {
      ::TGuiBuilder *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGuiBuilder >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGuiBuilder", ::TGuiBuilder::Class_Version(), "include/TGuiBuilder.h", 52,
                  typeid(::TGuiBuilder), DefineBehavior(ptr, ptr),
                  &::TGuiBuilder::Dictionary, isa_proxy, 0,
                  sizeof(::TGuiBuilder) );
      instance.SetNew(&new_TGuiBuilder);
      instance.SetNewArray(&newArray_TGuiBuilder);
      instance.SetDelete(&delete_TGuiBuilder);
      instance.SetDeleteArray(&deleteArray_TGuiBuilder);
      instance.SetDestructor(&destruct_TGuiBuilder);
      instance.SetStreamerFunc(&streamer_TGuiBuilder);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGuiBuilder*)
   {
      return GenerateInitInstanceLocal((::TGuiBuilder*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGuiBuilder*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGRedirectOutputGuard_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGRedirectOutputGuard(void *p);
   static void deleteArray_TGRedirectOutputGuard(void *p);
   static void destruct_TGRedirectOutputGuard(void *p);
   static void streamer_TGRedirectOutputGuard(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGPasswdDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGPasswdDialog(void *p);
   static void deleteArray_TGPasswdDialog(void *p);
   static void destruct_TGPasswdDialog(void *p);
   static void streamer_TGPasswdDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTextEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextEditor(void *p = 0);
   static void *newArray_TGTextEditor(Long_t size, void *p);
   static void delete_TGTextEditor(void *p);
   static void deleteArray_TGTextEditor(void *p);
   static void destruct_TGTextEditor(void *p);
   static void streamer_TGTextEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSpeedo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGSpeedo(void *p = 0);
   static void *newArray_TGSpeedo(Long_t size, void *p);
   static void delete_TGSpeedo(void *p);
   static void deleteArray_TGSpeedo(void *p);
   static void destruct_TGSpeedo(void *p);
   static void streamer_TGSpeedo(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGDragWindow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGDragWindow(void *p);
   static void deleteArray_TGDragWindow(void *p);
   static void destruct_TGDragWindow(void *p);
   static void streamer_TGDragWindow(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTable(void *p = 0);
   static void *newArray_TGTable(Long_t size, void *p);
   static void delete_TGTable(void *p);
   static void deleteArray_TGTable(void *p);
   static void destruct_TGTable(void *p);
   static void streamer_TGTable(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTableCell_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTableCell(void *p = 0);
   static void *newArray_TGTableCell(Long_t size, void *p);
   static void delete_TGTableCell(void *p);
   static void deleteArray_TGTableCell(void *p);
   static void destruct_TGTableCell(void *p);
   static void streamer_TGTableCell(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTableCell*)
   {
      ::TGTableCell *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTableCell >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTableCell", ::TGTableCell::Class_Version(), "include/TGTableCell.h", 26,
                  typeid(::TGTableCell), DefineBehavior(ptr, ptr),
                  &::TGTableCell::Dictionary, isa_proxy, 0,
                  sizeof(::TGTableCell) );
      instance.SetNew(&new_TGTableCell);
      instance.SetNewArray(&newArray_TGTableCell);
      instance.SetDelete(&delete_TGTableCell);
      instance.SetDeleteArray(&deleteArray_TGTableCell);
      instance.SetDestructor(&destruct_TGTableCell);
      instance.SetStreamerFunc(&streamer_TGTableCell);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTableCell*)
   {
      return GenerateInitInstanceLocal((::TGTableCell*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTableCell*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTableHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTableHeader(void *p = 0);
   static void *newArray_TGTableHeader(Long_t size, void *p);
   static void delete_TGTableHeader(void *p);
   static void deleteArray_TGTableHeader(void *p);
   static void destruct_TGTableHeader(void *p);
   static void streamer_TGTableHeader(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTableHeader*)
   {
      ::TGTableHeader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTableHeader >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTableHeader", ::TGTableHeader::Class_Version(), "include/TGTableHeader.h", 26,
                  typeid(::TGTableHeader), DefineBehavior(ptr, ptr),
                  &::TGTableHeader::Dictionary, isa_proxy, 0,
                  sizeof(::TGTableHeader) );
      instance.SetNew(&new_TGTableHeader);
      instance.SetNewArray(&newArray_TGTableHeader);
      instance.SetDelete(&delete_TGTableHeader);
      instance.SetDeleteArray(&deleteArray_TGTableHeader);
      instance.SetDestructor(&destruct_TGTableHeader);
      instance.SetStreamerFunc(&streamer_TGTableHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTableHeader*)
   {
      return GenerateInitInstanceLocal((::TGTableHeader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTableHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTableFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGTableFrame(void *p);
   static void deleteArray_TGTableFrame(void *p);
   static void destruct_TGTableFrame(void *p);
   static void streamer_TGTableFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTableHeaderFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGTableHeaderFrame(void *p);
   static void deleteArray_TGTableHeaderFrame(void *p);
   static void destruct_TGTableHeaderFrame(void *p);
   static void streamer_TGTableHeaderFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TTableRange_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTableRange(void *p = 0);
   static void *newArray_TTableRange(Long_t size, void *p);
   static void delete_TTableRange(void *p);
   static void deleteArray_TTableRange(void *p);
   static void destruct_TTableRange(void *p);
   static void streamer_TTableRange(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTableRange*)
   {
      ::TTableRange *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTableRange >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTableRange", ::TTableRange::Class_Version(), "include/TGTable.h", 234,
                  typeid(::TTableRange), DefineBehavior(ptr, ptr),
                  &::TTableRange::Dictionary, isa_proxy, 0,
                  sizeof(::TTableRange) );
      instance.SetNew(&new_TTableRange);
      instance.SetNewArray(&newArray_TTableRange);
      instance.SetDelete(&delete_TTableRange);
      instance.SetDeleteArray(&deleteArray_TTableRange);
      instance.SetDestructor(&destruct_TTableRange);
      instance.SetStreamerFunc(&streamer_TTableRange);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTableRange*)
   {
      return GenerateInitInstanceLocal((::TTableRange*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTableRange*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGSimpleTableInterface_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGSimpleTableInterface(void *p);
   static void deleteArray_TGSimpleTableInterface(void *p);
   static void destruct_TGSimpleTableInterface(void *p);
   static void streamer_TGSimpleTableInterface(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSimpleTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGSimpleTable(void *p);
   static void deleteArray_TGSimpleTable(void *p);
   static void destruct_TGSimpleTable(void *p);
   static void streamer_TGSimpleTable(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGCommandPlugin_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGCommandPlugin(void *p);
   static void deleteArray_TGCommandPlugin(void *p);
   static void destruct_TGCommandPlugin(void *p);
   static void streamer_TGCommandPlugin(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TRootBrowser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRootBrowser(void *p = 0);
   static void *newArray_TRootBrowser(Long_t size, void *p);
   static void delete_TRootBrowser(void *p);
   static void deleteArray_TRootBrowser(void *p);
   static void destruct_TRootBrowser(void *p);
   static void streamer_TRootBrowser(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRootBrowser*)
   {
      ::TRootBrowser *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRootBrowser >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRootBrowser", ::TRootBrowser::Class_Version(), "include/TRootBrowser.h", 57,
                  typeid(::TRootBrowser), DefineBehavior(ptr, ptr),
                  &::TRootBrowser::Dictionary, isa_proxy, 0,
                  sizeof(::TRootBrowser) );
      instance.SetNew(&new_TRootBrowser);
      instance.SetNewArray(&newArray_TRootBrowser);
      instance.SetDelete(&delete_TRootBrowser);
      instance.SetDeleteArray(&deleteArray_TRootBrowser);
      instance.SetDestructor(&destruct_TRootBrowser);
      instance.SetStreamerFunc(&streamer_TRootBrowser);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRootBrowser*)
   {
      return GenerateInitInstanceLocal((::TRootBrowser*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRootBrowser*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFileBrowser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGFileBrowser(void *p);
   static void deleteArray_TGFileBrowser(void *p);
   static void destruct_TGFileBrowser(void *p);
   static void streamer_TGFileBrowser(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TBrowserPlugin_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TBrowserPlugin(void *p);
   static void deleteArray_TBrowserPlugin(void *p);
   static void destruct_TBrowserPlugin(void *p);
   static void streamer_TBrowserPlugin(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGRectMap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGRectMap(void *p);
   static void deleteArray_TGRectMap(void *p);
   static void destruct_TGRectMap(void *p);
   static void streamer_TGRectMap(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSplitTool_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGSplitTool(void *p = 0);
   static void *newArray_TGSplitTool(Long_t size, void *p);
   static void delete_TGSplitTool(void *p);
   static void deleteArray_TGSplitTool(void *p);
   static void destruct_TGSplitTool(void *p);
   static void streamer_TGSplitTool(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSplitFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGSplitFrame(void *p = 0);
   static void *newArray_TGSplitFrame(Long_t size, void *p);
   static void delete_TGSplitFrame(void *p);
   static void deleteArray_TGSplitFrame(void *p);
   static void destruct_TGSplitFrame(void *p);
   static void streamer_TGSplitFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGSplitFrame*)
   {
      ::TGSplitFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGSplitFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGSplitFrame", ::TGSplitFrame::Class_Version(), "include/TGSplitFrame.h", 81,
                  typeid(::TGSplitFrame), DefineBehavior(ptr, ptr),
                  &::TGSplitFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGSplitFrame) );
      instance.SetNew(&new_TGSplitFrame);
      instance.SetNewArray(&newArray_TGSplitFrame);
      instance.SetDelete(&delete_TGSplitFrame);
      instance.SetDeleteArray(&deleteArray_TGSplitFrame);
      instance.SetDestructor(&destruct_TGSplitFrame);
      instance.SetStreamerFunc(&streamer_TGSplitFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGSplitFrame*)
   {
      return GenerateInitInstanceLocal((::TGSplitFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGSplitFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGShapedFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGShapedFrame(void *p = 0);
   static void *newArray_TGShapedFrame(Long_t size, void *p);
   static void delete_TGShapedFrame(void *p);
   static void deleteArray_TGShapedFrame(void *p);
   static void destruct_TGShapedFrame(void *p);
   static void streamer_TGShapedFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGEventHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGEventHandler(void *p);
   static void deleteArray_TGEventHandler(void *p);
   static void destruct_TGEventHandler(void *p);
   static void streamer_TGEventHandler(TBuffer &buf, void *obj);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   TGuiFactory::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootGuiFactory(void *p) {
      return  p ? new(p) ::TRootGuiFactory : new ::TRootGuiFactory;
   }
   static void *newArray_TRootGuiFactory(Long_t nElements, void *p) {
      return p ? new(p) ::TRootGuiFactory[nElements] : new ::TRootGuiFactory[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootGuiFactory(void *p) {
      delete ((::TRootGuiFactory*)p);
   }
   static void deleteArray_TRootGuiFactory(void *p) {
      delete [] ((::TRootGuiFactory*)p);
   }
   static void destruct_TRootGuiFactory(void *p) {
      typedef ::TRootGuiFactory current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootGuiFactory(TBuffer &buf, void *obj) {
      ((::TRootGuiFactory*)obj)->::TRootGuiFactory::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootGuiFactory

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

   TApplicationImp::Streamer(R__b);
}

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

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

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

   TGMainFrame::Streamer(R__b);
   TCanvasImp::Streamer(R__b);
}

//______________________________________________________________________________
void TRootCanvas::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRootCanvas.
      TClass *R__cl = ::TRootCanvas::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasWindow", &fCanvasWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasContainer", &fCanvasContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileMenu", &fFileMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileSaveMenu", &fFileSaveMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMenu", &fEditMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditClearMenu", &fEditClearMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewMenu", &fViewMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewWithMenu", &fViewWithMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptionMenu", &fOptionMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolsMenu", &fToolsMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHelpMenu", &fHelpMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarLayout", &fMenuBarLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarItemLayout", &fMenuBarItemLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarHelpLayout", &fMenuBarHelpLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasLayout", &fCanvasLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBar", &fStatusBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBarLayout", &fStatusBarLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditorFrame", &fEditorFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditorLayout", &fEditorLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainFrame", &fMainFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarLayout", &fToolBarLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBar", &fToolBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarSep", &fToolBarSep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainFrameLayout", &fMainFrameLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVertical1", &fVertical1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVertical2", &fVertical2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHorizontal1", &fHorizontal1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVertical1Layout", &fVertical1Layout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVertical2Layout", &fVertical2Layout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHorizontal1Layout", &fHorizontal1Layout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolDock", &fToolDock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDockLayout", &fDockLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIconPic", &fIconPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolTip", &fToolTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditor", &fEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanvasID", &fCanvasID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoFit", &fAutoFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fButton", &fButton);
      TGMainFrame::ShowMembers(R__insp);
      TCanvasImp::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootCanvas(void *p) {
      return  p ? new(p) ::TRootCanvas : new ::TRootCanvas;
   }
   static void *newArray_TRootCanvas(Long_t nElements, void *p) {
      return p ? new(p) ::TRootCanvas[nElements] : new ::TRootCanvas[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootCanvas(void *p) {
      delete ((::TRootCanvas*)p);
   }
   static void deleteArray_TRootCanvas(void *p) {
      delete [] ((::TRootCanvas*)p);
   }
   static void destruct_TRootCanvas(void *p) {
      typedef ::TRootCanvas current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootCanvas(TBuffer &buf, void *obj) {
      ((::TRootCanvas*)obj)->::TRootCanvas::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootCanvas

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

   TGCanvas::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootEmbeddedCanvas(void *p) {
      return  p ? new(p) ::TRootEmbeddedCanvas : new ::TRootEmbeddedCanvas;
   }
   static void *newArray_TRootEmbeddedCanvas(Long_t nElements, void *p) {
      return p ? new(p) ::TRootEmbeddedCanvas[nElements] : new ::TRootEmbeddedCanvas[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootEmbeddedCanvas(void *p) {
      delete ((::TRootEmbeddedCanvas*)p);
   }
   static void deleteArray_TRootEmbeddedCanvas(void *p) {
      delete [] ((::TRootEmbeddedCanvas*)p);
   }
   static void destruct_TRootEmbeddedCanvas(void *p) {
      typedef ::TRootEmbeddedCanvas current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootEmbeddedCanvas(TBuffer &buf, void *obj) {
      ((::TRootEmbeddedCanvas*)obj)->::TRootEmbeddedCanvas::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootEmbeddedCanvas

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

   TGMainFrame::Streamer(R__b);
   TBrowserImp::Streamer(R__b);
}

//______________________________________________________________________________
void TRootBrowserLite::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRootBrowserLite.
      TClass *R__cl = ::TRootBrowserLite::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBar", &fToolBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarSep", &fToolBarSep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV1", &fV1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV2", &fV2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLbl1", &fLbl1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLbl2", &fLbl2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHf", &fHf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeHdr", &fTreeHdr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListHdr", &fListHdr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarLayout", &fMenuBarLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarItemLayout", &fMenuBarItemLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarHelpLayout", &fMenuBarHelpLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboLayout", &fComboLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarLayout", &fBarLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawOption", &fDrawOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExpandLayout", &fExpandLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBrowseTextFile", &fBrowseTextFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextFileName", &fTextFileName);
      R__insp.InspectMember(fTextFileName, "fTextFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWidgets", &fWidgets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistory", &fHistory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistoryCursor", &fHistoryCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIconPic", &fIconPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileMenu", &fFileMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewMenu", &fViewMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptionMenu", &fOptionMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHelpMenu", &fHelpMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSortMenu", &fSortMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListView", &fListView);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIconBox", &fIconBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeView", &fTreeView);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLt", &fLt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarButton[7]", &fToolBarButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFSComboBox", &fFSComboBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBar", &fStatusBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListLevel", &fListLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeLock", &fTreeLock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewMode", &fViewMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSortMode", &fSortMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextEdit", &fTextEdit);
      TGMainFrame::ShowMembers(R__insp);
      TBrowserImp::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootBrowserLite(void *p) {
      return  p ? new(p) ::TRootBrowserLite : new ::TRootBrowserLite;
   }
   static void *newArray_TRootBrowserLite(Long_t nElements, void *p) {
      return p ? new(p) ::TRootBrowserLite[nElements] : new ::TRootBrowserLite[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootBrowserLite(void *p) {
      delete ((::TRootBrowserLite*)p);
   }
   static void deleteArray_TRootBrowserLite(void *p) {
      delete [] ((::TRootBrowserLite*)p);
   }
   static void destruct_TRootBrowserLite(void *p) {
      typedef ::TRootBrowserLite current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootBrowserLite(TBuffer &buf, void *obj) {
      ((::TRootBrowserLite*)obj)->::TRootBrowserLite::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootBrowserLite

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

   TGPopupMenu::Streamer(R__b);
   TContextMenuImp::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootContextMenu(void *p) {
      return  p ? new(p) ::TRootContextMenu : new ::TRootContextMenu;
   }
   static void *newArray_TRootContextMenu(Long_t nElements, void *p) {
      return p ? new(p) ::TRootContextMenu[nElements] : new ::TRootContextMenu[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootContextMenu(void *p) {
      delete ((::TRootContextMenu*)p);
   }
   static void deleteArray_TRootContextMenu(void *p) {
      delete [] ((::TRootContextMenu*)p);
   }
   static void destruct_TRootContextMenu(void *p) {
      typedef ::TRootContextMenu current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootContextMenu(TBuffer &buf, void *obj) {
      ((::TRootContextMenu*)obj)->::TRootContextMenu::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootContextMenu

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TRootDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRootDialog.
      TClass *R__cl = ::TRootDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenu", &fMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL1", &fL1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL2", &fL2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWidgets", &fWidgets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOk", &fOk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCancel", &fCancel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHelp", &fHelp);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootDialog(void *p) {
      return  p ? new(p) ::TRootDialog : new ::TRootDialog;
   }
   static void *newArray_TRootDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TRootDialog[nElements] : new ::TRootDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootDialog(void *p) {
      delete ((::TRootDialog*)p);
   }
   static void deleteArray_TRootDialog(void *p) {
      delete [] ((::TRootDialog*)p);
   }
   static void destruct_TRootDialog(void *p) {
      typedef ::TRootDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootDialog(TBuffer &buf, void *obj) {
      ((::TRootDialog*)obj)->::TRootDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootDialog

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

   TGMainFrame::Streamer(R__b);
   TControlBarImp::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootControlBar(void *p) {
      return  p ? new(p) ::TRootControlBar : new ::TRootControlBar;
   }
   static void *newArray_TRootControlBar(Long_t nElements, void *p) {
      return p ? new(p) ::TRootControlBar[nElements] : new ::TRootControlBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootControlBar(void *p) {
      delete ((::TRootControlBar*)p);
   }
   static void deleteArray_TRootControlBar(void *p) {
      delete [] ((::TRootControlBar*)p);
   }
   static void destruct_TRootControlBar(void *p) {
      typedef ::TRootControlBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootControlBar(TBuffer &buf, void *obj) {
      ((::TRootControlBar*)obj)->::TRootControlBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootControlBar

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

   TGTransientFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootHelpDialog(void *p) {
      return  p ? new(p) ::TRootHelpDialog : new ::TRootHelpDialog;
   }
   static void *newArray_TRootHelpDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TRootHelpDialog[nElements] : new ::TRootHelpDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootHelpDialog(void *p) {
      delete ((::TRootHelpDialog*)p);
   }
   static void deleteArray_TRootHelpDialog(void *p) {
      delete [] ((::TRootHelpDialog*)p);
   }
   static void destruct_TRootHelpDialog(void *p) {
      typedef ::TRootHelpDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootHelpDialog(TBuffer &buf, void *obj) {
      ((::TRootHelpDialog*)obj)->::TRootHelpDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootHelpDialog

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGColorFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGColorFrame.
      TClass *R__cl = ::TGColorFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPixel", &fPixel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrayGC", &fGrayGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGColorFrame(void *p) {
      return  p ? new(p) ::TGColorFrame : new ::TGColorFrame;
   }
   static void *newArray_TGColorFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGColorFrame[nElements] : new ::TGColorFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGColorFrame(void *p) {
      delete ((::TGColorFrame*)p);
   }
   static void deleteArray_TGColorFrame(void *p) {
      delete [] ((::TGColorFrame*)p);
   }
   static void destruct_TGColorFrame(void *p) {
      typedef ::TGColorFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGColorFrame(TBuffer &buf, void *obj) {
      ((::TGColorFrame*)obj)->::TGColorFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGColorFrame

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TG16ColorSelector::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TG16ColorSelector.
      TClass *R__cl = ::TG16ColorSelector::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCe[16]", &fCe);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TG16ColorSelector(void *p) {
      return  p ? new(p) ::TG16ColorSelector : new ::TG16ColorSelector;
   }
   static void *newArray_TG16ColorSelector(Long_t nElements, void *p) {
      return p ? new(p) ::TG16ColorSelector[nElements] : new ::TG16ColorSelector[nElements];
   }
   // Wrapper around operator delete
   static void delete_TG16ColorSelector(void *p) {
      delete ((::TG16ColorSelector*)p);
   }
   static void deleteArray_TG16ColorSelector(void *p) {
      delete [] ((::TG16ColorSelector*)p);
   }
   static void destruct_TG16ColorSelector(void *p) {
      typedef ::TG16ColorSelector current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TG16ColorSelector(TBuffer &buf, void *obj) {
      ((::TG16ColorSelector*)obj)->::TG16ColorSelector::Streamer(buf);
   }
} // end of namespace ROOT for class ::TG16ColorSelector

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGColorPopup(void *p) {
      return  p ? new(p) ::TGColorPopup : new ::TGColorPopup;
   }
   static void *newArray_TGColorPopup(Long_t nElements, void *p) {
      return p ? new(p) ::TGColorPopup[nElements] : new ::TGColorPopup[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGColorPopup(void *p) {
      delete ((::TGColorPopup*)p);
   }
   static void deleteArray_TGColorPopup(void *p) {
      delete [] ((::TGColorPopup*)p);
   }
   static void destruct_TGColorPopup(void *p) {
      typedef ::TGColorPopup current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGColorPopup(TBuffer &buf, void *obj) {
      ((::TGColorPopup*)obj)->::TGColorPopup::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGColorPopup

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

   TGCheckButton::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGColorSelect(void *p) {
      return  p ? new(p) ::TGColorSelect : new ::TGColorSelect;
   }
   static void *newArray_TGColorSelect(Long_t nElements, void *p) {
      return p ? new(p) ::TGColorSelect[nElements] : new ::TGColorSelect[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGColorSelect(void *p) {
      delete ((::TGColorSelect*)p);
   }
   static void deleteArray_TGColorSelect(void *p) {
      delete [] ((::TGColorSelect*)p);
   }
   static void destruct_TGColorSelect(void *p) {
      typedef ::TGColorSelect current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGColorSelect(TBuffer &buf, void *obj) {
      ((::TGColorSelect*)obj)->::TGColorSelect::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGColorSelect

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

   TGFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGColorPalette::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGColorPalette.
      TClass *R__cl = ::TGColorPalette::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCx", &fCx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCy", &fCy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCw", &fCw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCh", &fCh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRows", &fRows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCols", &fCols);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPixels", &fPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawGC", &fDrawGC);
      R__insp.InspectMember(fDrawGC, "fDrawGC.");
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGColorPalette(void *p) {
      return  p ? new(p) ::TGColorPalette : new ::TGColorPalette;
   }
   static void *newArray_TGColorPalette(Long_t nElements, void *p) {
      return p ? new(p) ::TGColorPalette[nElements] : new ::TGColorPalette[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGColorPalette(void *p) {
      delete ((::TGColorPalette*)p);
   }
   static void deleteArray_TGColorPalette(void *p) {
      delete [] ((::TGColorPalette*)p);
   }
   static void destruct_TGColorPalette(void *p) {
      typedef ::TGColorPalette current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGColorPalette(TBuffer &buf, void *obj) {
      ((::TGColorPalette*)obj)->::TGColorPalette::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGColorPalette

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

   TGFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGColorPick::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGColorPick.
      TClass *R__cl = ::TGColorPick::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColormap[64][3]", fColormap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPixel[64]", fPixel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHSimage", &fHSimage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimage", &fLimage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNColors", &fNColors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClick", &fClick);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCx", &fCx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCy", &fCy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCz", &fCz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentColor", &fCurrentColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColormapRect", (void*)&fColormapRect);
      R__insp.InspectMember("Rectangle_t", (void*)&fColormapRect, "fColormapRect.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderRect", (void*)&fSliderRect);
      R__insp.InspectMember("Rectangle_t", (void*)&fSliderRect, "fSliderRect.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorGC", &fCursorGC);
      R__insp.InspectMember(fCursorGC, "fCursorGC.");
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGColorPick(void *p) {
      return  p ? new(p) ::TGColorPick : new ::TGColorPick;
   }
   static void *newArray_TGColorPick(Long_t nElements, void *p) {
      return p ? new(p) ::TGColorPick[nElements] : new ::TGColorPick[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGColorPick(void *p) {
      delete ((::TGColorPick*)p);
   }
   static void deleteArray_TGColorPick(void *p) {
      delete [] ((::TGColorPick*)p);
   }
   static void destruct_TGColorPick(void *p) {
      typedef ::TGColorPick current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGColorPick(TBuffer &buf, void *obj) {
      ((::TGColorPick*)obj)->::TGColorPick::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGColorPick

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGColorDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGColorDialog.
      TClass *R__cl = ::TGColorDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentColor", &fCurrentColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitColor", &fInitColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetc", &fRetc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetColor", &fRetColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPalette", &fPalette);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCpalette", &fCpalette);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColors", &fColors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSample", &fSample);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSampleOld", &fSampleOld);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRte", &fRte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGte", &fGte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBte", &fBte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHte", &fHte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLte", &fLte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSte", &fSte);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRtb", &fRtb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGtb", &fGtb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBtb", &fBtb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHtb", &fHtb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLtb", &fLtb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStb", &fStb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaitFor", &fWaitFor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEcanvas", &fEcanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorWheel", &fColorWheel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorInfo", &fColorInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreview", &fPreview);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGColorDialog(void *p) {
      return  p ? new(p) ::TGColorDialog : new ::TGColorDialog;
   }
   static void *newArray_TGColorDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGColorDialog[nElements] : new ::TGColorDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGColorDialog(void *p) {
      delete ((::TGColorDialog*)p);
   }
   static void deleteArray_TGColorDialog(void *p) {
      delete [] ((::TGColorDialog*)p);
   }
   static void destruct_TGColorDialog(void *p) {
      typedef ::TGColorDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGColorDialog(TBuffer &buf, void *obj) {
      ((::TGColorDialog*)obj)->::TGColorDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGColorDialog

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGFontDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFontDialog.
      TClass *R__cl = ::TGFontDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontNames", &fFontNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontSizes", &fFontSizes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontStyles", &fFontStyles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextAligns", &fTextAligns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSample", &fSample);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLName", &fLName);
      R__insp.InspectMember(fLName, "fLName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontProp", &fFontProp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fItalic", &fItalic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBold", &fBold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      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(), "fInitColor", &fInitColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitAlign", &fInitAlign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInitFont", &fInitFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSampleText", &fSampleText);
      R__insp.InspectMember(fSampleText, "fSampleText.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSampleTextGC", &fSampleTextGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelFont", &fLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHitOK", &fHitOK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumberOfFonts", &fNumberOfFonts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaitFor", &fWaitFor);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFontDialog(void *p) {
      return  p ? new(p) ::TGFontDialog : new ::TGFontDialog;
   }
   static void *newArray_TGFontDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGFontDialog[nElements] : new ::TGFontDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFontDialog(void *p) {
      delete ((::TGFontDialog*)p);
   }
   static void deleteArray_TGFontDialog(void *p) {
      delete [] ((::TGFontDialog*)p);
   }
   static void destruct_TGFontDialog(void *p) {
      typedef ::TGFontDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFontDialog(TBuffer &buf, void *obj) {
      ((::TGFontDialog*)obj)->::TGFontDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFontDialog

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFontDialogcLcLFontProp_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGFontDialog::FontProp_t : new ::TGFontDialog::FontProp_t;
   }
   static void *newArray_TGFontDialogcLcLFontProp_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGFontDialog::FontProp_t[nElements] : new ::TGFontDialog::FontProp_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFontDialogcLcLFontProp_t(void *p) {
      delete ((::TGFontDialog::FontProp_t*)p);
   }
   static void deleteArray_TGFontDialogcLcLFontProp_t(void *p) {
      delete [] ((::TGFontDialog::FontProp_t*)p);
   }
   static void destruct_TGFontDialogcLcLFontProp_t(void *p) {
      typedef ::TGFontDialog::FontProp_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGFontDialog::FontProp_t

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

   TGCompositeFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGDockableFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGDockableFrame.
      TClass *R__cl = ::TGDockableFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHidden", &fHidden);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnableHide", &fEnableHide);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnableUndock", &fEnableUndock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeleted", &fDeleted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixedSize", &fFixedSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDockName", &fDockName);
      R__insp.InspectMember(fDockName, "fDockName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContainer", &fContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtons", &fButtons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDockButton", &fDockButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHideButton", &fHideButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCl", &fCl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHints", &fHints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLb", &fLb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLc", &fLc);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGDockableFrame(void *p) {
      return  p ? new(p) ::TGDockableFrame : new ::TGDockableFrame;
   }
   static void *newArray_TGDockableFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGDockableFrame[nElements] : new ::TGDockableFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGDockableFrame(void *p) {
      delete ((::TGDockableFrame*)p);
   }
   static void deleteArray_TGDockableFrame(void *p) {
      delete [] ((::TGDockableFrame*)p);
   }
   static void destruct_TGDockableFrame(void *p) {
      typedef ::TGDockableFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGDockableFrame(TBuffer &buf, void *obj) {
      ((::TGDockableFrame*)obj)->::TGDockableFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGDockableFrame

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

   TGTransientFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGUndockedFrame(void *p) {
      return  p ? new(p) ::TGUndockedFrame : new ::TGUndockedFrame;
   }
   static void *newArray_TGUndockedFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGUndockedFrame[nElements] : new ::TGUndockedFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGUndockedFrame(void *p) {
      delete ((::TGUndockedFrame*)p);
   }
   static void deleteArray_TGUndockedFrame(void *p) {
      delete [] ((::TGUndockedFrame*)p);
   }
   static void destruct_TGUndockedFrame(void *p) {
      typedef ::TGUndockedFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGUndockedFrame(TBuffer &buf, void *obj) {
      ((::TGUndockedFrame*)obj)->::TGUndockedFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGUndockedFrame

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

   TGButton::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGDockButton(void *p) {
      return  p ? new(p) ::TGDockButton : new ::TGDockButton;
   }
   static void *newArray_TGDockButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGDockButton[nElements] : new ::TGDockButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGDockButton(void *p) {
      delete ((::TGDockButton*)p);
   }
   static void deleteArray_TGDockButton(void *p) {
      delete [] ((::TGDockButton*)p);
   }
   static void destruct_TGDockButton(void *p) {
      typedef ::TGDockButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGDockButton(TBuffer &buf, void *obj) {
      ((::TGDockButton*)obj)->::TGDockButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGDockButton

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

   TGDockButton::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGDockHideButton(void *p) {
      return  p ? new(p) ::TGDockHideButton : new ::TGDockHideButton;
   }
   static void *newArray_TGDockHideButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGDockHideButton[nElements] : new ::TGDockHideButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGDockHideButton(void *p) {
      delete ((::TGDockHideButton*)p);
   }
   static void deleteArray_TGDockHideButton(void *p) {
      delete [] ((::TGDockHideButton*)p);
   }
   static void destruct_TGDockHideButton(void *p) {
      typedef ::TGDockHideButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGDockHideButton(TBuffer &buf, void *obj) {
      ((::TGDockHideButton*)obj)->::TGDockHideButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGDockHideButton

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMdiMenuBar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiMenuBar.
      TClass *R__cl = ::TGMdiMenuBar::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeft", &fLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRight", &fRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBar", &fBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLHint", &fLHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeftHint", &fLeftHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRightHint", &fRightHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarHint", &fBarHint);
      TGCompositeFrame::ShowMembers(R__insp);
}

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

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

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

//______________________________________________________________________________
void TGMdiFrameList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiFrameList.
      TClass *R__cl = ::TGMdiFrameList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameId", &fFrameId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDecor", &fDecor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrev", &fPrev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNext", &fNext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCyclePrev", &fCyclePrev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCycleNext", &fCycleNext);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMdiFrameList(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGMdiFrameList : new ::TGMdiFrameList;
   }
   static void *newArray_TGMdiFrameList(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGMdiFrameList[nElements] : new ::TGMdiFrameList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMdiFrameList(void *p) {
      delete ((::TGMdiFrameList*)p);
   }
   static void deleteArray_TGMdiFrameList(void *p) {
      delete [] ((::TGMdiFrameList*)p);
   }
   static void destruct_TGMdiFrameList(void *p) {
      typedef ::TGMdiFrameList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMdiFrameList(TBuffer &buf, void *obj) {
      ((::TGMdiFrameList*)obj)->::TGMdiFrameList::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMdiFrameList

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMdiGeometry(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGMdiGeometry : new ::TGMdiGeometry;
   }
   static void *newArray_TGMdiGeometry(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGMdiGeometry[nElements] : new ::TGMdiGeometry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMdiGeometry(void *p) {
      delete ((::TGMdiGeometry*)p);
   }
   static void deleteArray_TGMdiGeometry(void *p) {
      delete [] ((::TGMdiGeometry*)p);
   }
   static void destruct_TGMdiGeometry(void *p) {
      typedef ::TGMdiGeometry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMdiGeometry(TBuffer &buf, void *obj) {
      ((::TGMdiGeometry*)obj)->::TGMdiGeometry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMdiGeometry

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

   TGCanvas::Streamer(R__b);
}

//______________________________________________________________________________
void TGMdiMainFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiMainFrame.
      TClass *R__cl = ::TGMdiMainFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentX", &fCurrentX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentY", &fCurrentY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResizeMode", &fResizeMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArrangementMode", &fArrangementMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontCurrent", &fFontCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontNotCurrent", &fFontNotCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackCurrent", &fBackCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForeCurrent", &fForeCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackNotCurrent", &fBackNotCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForeNotCurrent", &fForeNotCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxGC", &fBoxGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumberOfFrames", &fNumberOfFrames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContainer", &fContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWinListMenu", &fWinListMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChildren", &fChildren);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      TGCanvas::ShowMembers(R__insp);
}

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

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

   TGFrame::Streamer(R__b);
}

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

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

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

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

   TGFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGMdiWinResizer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiWinResizer.
      TClass *R__cl = ::TGMdiWinResizer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdiWin", &fMdiWin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWinX", &fWinX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWinY", &fWinY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWinW", &fWinW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWinH", &fWinH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldX", &fOldX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldY", &fOldY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldW", &fOldW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldH", &fOldH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewX", &fNewX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewY", &fNewY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewW", &fNewW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewH", &fNewH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinW", &fMinW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinH", &fMinH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdiOptions", &fMdiOptions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftButPressed", &fLeftButPressed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRightButPressed", &fRightButPressed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMidButPressed", &fMidButPressed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxGC", &fBoxGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineW", &fLineW);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

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

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

   TGMdiWinResizer::Streamer(R__b);
}

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

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

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

   TGMdiWinResizer::Streamer(R__b);
}

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

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

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

   TGMdiWinResizer::Streamer(R__b);
}

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMdiButtons::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiButtons.
      TClass *R__cl = ::TGMdiButtons::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButton[5]", &fButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultHint", &fDefaultHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCloseHint", &fCloseHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
      TGCompositeFrame::ShowMembers(R__insp);
}

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

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

   TGIcon::Streamer(R__b);
}

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMdiTitleBar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiTitleBar.
      TClass *R__cl = ::TGMdiTitleBar::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdiWin", &fMdiWin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtons", &fButtons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWinIcon", &fWinIcon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWinName", &fWinName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLFrame", &fLFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMFrame", &fMFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRFrame", &fRFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLHint", &fLHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeftHint", &fLeftHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMiddleHint", &fMiddleHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRightHint", &fRightHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftButPressed", &fLeftButPressed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRightButPressed", &fRightButPressed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMidButPressed", &fMidButPressed);
      TGCompositeFrame::ShowMembers(R__insp);
}

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

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMdiDecorFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMdiDecorFrame.
      TClass *R__cl = ::TGMdiDecorFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPreResizeX", &fPreResizeX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPreResizeY", &fPreResizeY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPreResizeWidth", &fPreResizeWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPreResizeHeight", &fPreResizeHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizedX", &fMinimizedX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizedY", &fMinimizedY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMinimized", &fIsMinimized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMaximized", &fIsMaximized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizedUserPlacement", &fMinimizedUserPlacement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsCurrent", &fIsCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdiMainFrame", &fMdiMainFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpperHR", &fUpperHR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLowerHR", &fLowerHR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpperLeftCR", &fUpperLeftCR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLowerLeftCR", &fLowerLeftCR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpperRightCR", &fUpperRightCR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLowerRightCR", &fLowerRightCR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeftVR", &fLeftVR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRightVR", &fRightVR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLHint", &fLHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExpandHint", &fExpandHint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fButtonMask", &fButtonMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitlebar", &fTitlebar);
      TGCompositeFrame::ShowMembers(R__insp);
}

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

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

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

//______________________________________________________________________________
void TVirtualDragManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualDragManager.
      TClass *R__cl = ::TVirtualDragManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMoveWaiting", &fMoveWaiting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragging", &fDragging);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDropping", &fDropping);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPasting", &fPasting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragType", &fDragType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSource", &fSource);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameUnder", &fFrameUnder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTarget", &fTarget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPasteFrame", &fPasteFrame);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVirtualDragManager(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TVirtualDragManager : new ::TVirtualDragManager;
   }
   static void *newArray_TVirtualDragManager(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TVirtualDragManager[nElements] : new ::TVirtualDragManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVirtualDragManager(void *p) {
      delete ((::TVirtualDragManager*)p);
   }
   static void deleteArray_TVirtualDragManager(void *p) {
      delete [] ((::TVirtualDragManager*)p);
   }
   static void destruct_TVirtualDragManager(void *p) {
      typedef ::TVirtualDragManager current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TVirtualDragManager(TBuffer &buf, void *obj) {
      ((::TVirtualDragManager*)obj)->::TVirtualDragManager::Streamer(buf);
   }
} // end of namespace ROOT for class ::TVirtualDragManager

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGuiBuilder(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGuiBuilder : new ::TGuiBuilder;
   }
   static void *newArray_TGuiBuilder(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGuiBuilder[nElements] : new ::TGuiBuilder[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGuiBuilder(void *p) {
      delete ((::TGuiBuilder*)p);
   }
   static void deleteArray_TGuiBuilder(void *p) {
      delete [] ((::TGuiBuilder*)p);
   }
   static void destruct_TGuiBuilder(void *p) {
      typedef ::TGuiBuilder current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGuiBuilder(TBuffer &buf, void *obj) {
      ((::TGuiBuilder*)obj)->::TGuiBuilder::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGuiBuilder

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TGuiBldAction::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGuiBldAction.
      TClass *R__cl = ::TGuiBldAction::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(), "fAct", &fAct);
      R__insp.InspectMember(fAct, "fAct.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicture", &fPicture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHints", &fHints);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGuiBldAction(void *p) {
      return  p ? new(p) ::TGuiBldAction : new ::TGuiBldAction;
   }
   static void *newArray_TGuiBldAction(Long_t nElements, void *p) {
      return p ? new(p) ::TGuiBldAction[nElements] : new ::TGuiBldAction[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGuiBldAction(void *p) {
      delete ((::TGuiBldAction*)p);
   }
   static void deleteArray_TGuiBldAction(void *p) {
      delete [] ((::TGuiBldAction*)p);
   }
   static void destruct_TGuiBldAction(void *p) {
      typedef ::TGuiBldAction current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGuiBldAction(TBuffer &buf, void *obj) {
      ((::TGuiBldAction*)obj)->::TGuiBldAction::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGuiBldAction

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

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

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

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

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

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

//______________________________________________________________________________
void TGPasswdDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGPasswdDialog.
      TClass *R__cl = ::TGPasswdDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPwdBuf", &fPwdBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPwdLenMax", &fPwdLenMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDialog", &fDialog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOk", &fOk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPasswd", &fPasswd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPasswdText", &fPasswdText);
}

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

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

   TGMainFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGTextEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTextEditor.
      TClass *R__cl = ::TGTextEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBar", &fStatusBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBar", &fToolBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextEdit", &fTextEdit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboCmd", &fComboCmd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCommand", &fCommand);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCommandBuf", &fCommandBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarLayout", &fMenuBarLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarItemLayout", &fMenuBarItemLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuFile", &fMenuFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuEdit", &fMenuEdit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuSearch", &fMenuSearch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuTools", &fMenuTools);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHelp", &fMenuHelp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExiting", &fExiting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextChanged", &fTextChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilename", &fFilename);
      R__insp.InspectMember(fFilename, "fFilename.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMacro", &fMacro);
      TGMainFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextEditor(void *p) {
      return  p ? new(p) ::TGTextEditor : new ::TGTextEditor;
   }
   static void *newArray_TGTextEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextEditor[nElements] : new ::TGTextEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextEditor(void *p) {
      delete ((::TGTextEditor*)p);
   }
   static void deleteArray_TGTextEditor(void *p) {
      delete [] ((::TGTextEditor*)p);
   }
   static void destruct_TGTextEditor(void *p) {
      typedef ::TGTextEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextEditor(TBuffer &buf, void *obj) {
      ((::TGTextEditor*)obj)->::TGTextEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextEditor

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

   TGFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGSpeedo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGSpeedo.
      TClass *R__cl = ::TGSpeedo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImage", &fImage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImage2", &fImage2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBase", &fBase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextFS", &fTextFS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCounterFS", &fCounterFS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCounter", &fCounter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPicName", &fPicName);
      R__insp.InspectMember(fPicName, "fPicName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel1", &fLabel1);
      R__insp.InspectMember(fLabel1, "fLabel1.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel2", &fLabel2);
      R__insp.InspectMember(fLabel2, "fLabel2.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisplay1", &fDisplay1);
      R__insp.InspectMember(fDisplay1, "fDisplay1.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisplay2", &fDisplay2);
      R__insp.InspectMember(fDisplay2, "fDisplay2.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle", &fAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeakVal", &fPeakVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanVal", &fMeanVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleMin", &fAngleMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleMax", &fAngleMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleMin", &fScaleMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleMax", &fScaleMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThreshold[3]", fThreshold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThresholdColor[3]", fThresholdColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThresholdActive", &fThresholdActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeakMark", &fPeakMark);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanMark", &fMeanMark);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGSpeedo(void *p) {
      return  p ? new(p) ::TGSpeedo : new ::TGSpeedo;
   }
   static void *newArray_TGSpeedo(Long_t nElements, void *p) {
      return p ? new(p) ::TGSpeedo[nElements] : new ::TGSpeedo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGSpeedo(void *p) {
      delete ((::TGSpeedo*)p);
   }
   static void deleteArray_TGSpeedo(void *p) {
      delete [] ((::TGSpeedo*)p);
   }
   static void destruct_TGSpeedo(void *p) {
      typedef ::TGSpeedo current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGSpeedo(TBuffer &buf, void *obj) {
      ((::TGSpeedo*)obj)->::TGSpeedo::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGSpeedo

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDNDData(void *p) {
      return  p ? new(p) ::TDNDData : new ::TDNDData;
   }
   static void *newArray_TDNDData(Long_t nElements, void *p) {
      return p ? new(p) ::TDNDData[nElements] : new ::TDNDData[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDNDData(void *p) {
      delete ((::TDNDData*)p);
   }
   static void deleteArray_TDNDData(void *p) {
      delete [] ((::TDNDData*)p);
   }
   static void destruct_TDNDData(void *p) {
      typedef ::TDNDData current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDNDData(TBuffer &buf, void *obj) {
      ((::TDNDData*)obj)->::TDNDData::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDNDData

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGDNDManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGDNDManager.
      TClass *R__cl = ::TGDNDManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMain", &fMain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypelist", &fTypelist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDraggerTypes", &fDraggerTypes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDropType", &fDropType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAcceptedAction", &fAcceptedAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalAction", &fLocalAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragging", &fDragging);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDropAccepted", &fDropAccepted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusPending", &fStatusPending);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseVersion", &fUseVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProxyOurs", &fProxyOurs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSource", &fSource);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTarget", &fTarget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargetIsDNDAware", &fTargetIsDNDAware);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrabEventMask", &fGrabEventMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLocalSource", &fLocalSource);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLocalTarget", &fLocalTarget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDropTimeout", &fDropTimeout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDragWin", &fDragWin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMask", &fMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHotx", &fHotx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHoty", &fHoty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDNDNoDropCursor", &fDNDNoDropCursor);
      TObject::ShowMembers(R__insp);
}

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

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGDragWindow::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGDragWindow.
      TClass *R__cl = ::TGDragWindow::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInput", &fInput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMask", &fMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPw", &fPw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPh", &fPh);
      TGFrame::ShowMembers(R__insp);
}

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

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGTableCell::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTableCell.
      TClass *R__cl = ::TGTableCell::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadOnly", &fReadOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnabled", &fEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMode", &fTMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImage", &fImage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTWidth", &fTWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTHeight", &fTHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasOwnFont", &fHasOwnFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColumn", &fColumn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRow", &fRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTable", &fTable);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTableCell(void *p) {
      return  p ? new(p) ::TGTableCell : new ::TGTableCell;
   }
   static void *newArray_TGTableCell(Long_t nElements, void *p) {
      return p ? new(p) ::TGTableCell[nElements] : new ::TGTableCell[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTableCell(void *p) {
      delete ((::TGTableCell*)p);
   }
   static void deleteArray_TGTableCell(void *p) {
      delete [] ((::TGTableCell*)p);
   }
   static void destruct_TGTableCell(void *p) {
      typedef ::TGTableCell current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTableCell(TBuffer &buf, void *obj) {
      ((::TGTableCell*)obj)->::TGTableCell::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTableCell

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

   TGTableCell::Streamer(R__b);
}

//______________________________________________________________________________
void TGTableHeader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTableHeader.
      TClass *R__cl = ::TGTableHeader::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(), "fWidth", &fWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadOnly", &fReadOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnabled", &fEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasOwnLabel", &fHasOwnLabel);
      TGTableCell::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTableHeader(void *p) {
      return  p ? new(p) ::TGTableHeader : new ::TGTableHeader;
   }
   static void *newArray_TGTableHeader(Long_t nElements, void *p) {
      return p ? new(p) ::TGTableHeader[nElements] : new ::TGTableHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTableHeader(void *p) {
      delete ((::TGTableHeader*)p);
   }
   static void deleteArray_TGTableHeader(void *p) {
      delete [] ((::TGTableHeader*)p);
   }
   static void destruct_TGTableHeader(void *p) {
      typedef ::TGTableHeader current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTableHeader(TBuffer &buf, void *obj) {
      ((::TGTableHeader*)obj)->::TGTableHeader::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTableHeader

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

   TGCompositeFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGTable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTable.
      TClass *R__cl = ::TGTable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRows", &fRows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRowHeaders", &fRowHeaders);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColumnHeaders", &fColumnHeaders);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTableHeader", &fTableHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadOnly", &fReadOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectColor", &fSelectColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMode", &fTMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllData", &fAllData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentRange", &fCurrentRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataRange", &fDataRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGotoRange", &fGotoRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTableFrame", &fTableFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellWidth", &fCellWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellHeight", &fCellHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCHdrFrame", &fCHdrFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRHdrFrame", &fRHdrFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRangeFrame", &fRangeFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopFrame", &fTopFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopExtraFrame", &fTopExtraFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBottomFrame", &fBottomFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtonFrame", &fButtonFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextButton", &fNextButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrevButton", &fPrevButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpdateButton", &fUpdateButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGotoButton", &fGotoButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstCellLabel", &fFirstCellLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRangeLabel", &fRangeLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstCellEntry", &fFirstCellEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRangeEntry", &fRangeEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOddRowBackground", &fOddRowBackground);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvenRowBackground", &fEvenRowBackground);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeaderBackground", &fHeaderBackground);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCellHintsList", &fCellHintsList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRHdrHintsList", &fRHdrHintsList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCHdrHintsList", &fCHdrHintsList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainHintsList", &fMainHintsList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterface", &fInterface);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTable(void *p) {
      return  p ? new(p) ::TGTable : new ::TGTable;
   }
   static void *newArray_TGTable(Long_t nElements, void *p) {
      return p ? new(p) ::TGTable[nElements] : new ::TGTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTable(void *p) {
      delete ((::TGTable*)p);
   }
   static void deleteArray_TGTable(void *p) {
      delete [] ((::TGTable*)p);
   }
   static void destruct_TGTable(void *p) {
      typedef ::TGTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTable(TBuffer &buf, void *obj) {
      ((::TGTable*)obj)->::TGTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTable

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTableRange(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTableRange : new ::TTableRange;
   }
   static void *newArray_TTableRange(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTableRange[nElements] : new ::TTableRange[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTableRange(void *p) {
      delete ((::TTableRange*)p);
   }
   static void deleteArray_TTableRange(void *p) {
      delete [] ((::TTableRange*)p);
   }
   static void destruct_TTableRange(void *p) {
      typedef ::TTableRange current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTableRange(TBuffer &buf, void *obj) {
      ((::TTableRange*)obj)->::TTableRange::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTableRange

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

   TQObject::Streamer(R__b);
}

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

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

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

   TGTable::Streamer(R__b);
}

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

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

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

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

   TVirtualTableInterface::Streamer(R__b);
}

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

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

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

   TGMainFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGCommandPlugin::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGCommandPlugin.
      TClass *R__cl = ::TGCommandPlugin::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPid", &fPid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHf", &fHf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboCmd", &fComboCmd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCommand", &fCommand);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCommandBuf", &fCommandBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
      TGMainFrame::ShowMembers(R__insp);
}

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

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

   TGMainFrame::Streamer(R__b);
   TBrowserImp::Streamer(R__b);
}

//______________________________________________________________________________
void TGFileBrowser::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFileBrowser.
      TClass *R__cl = ::TGFileBrowser::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewBrowser", &fNewBrowser);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopFrame", &fTopFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBotFrame", &fBotFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListTree", &fListTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListLevel", &fListLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentDir", &fCurrentDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootDir", &fRootDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawOption", &fDrawOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileType", &fFileType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContextMenu", &fContextMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSortButton", &fSortButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefreshButton", &fRefreshButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootIcon", &fRootIcon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileIcon", &fFileIcon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCachedPic", &fCachedPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCachedPicName", &fCachedPicName);
      R__insp.InspectMember(fCachedPicName, "fCachedPicName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFilter", &fFilter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDir", &fDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupSize", &fGroupSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNKeys", &fNKeys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCnt", &fCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrouped", &fGrouped);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowHidden", &fShowHidden);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDblClick", &fDblClick);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSortedItems", (void*)&fSortedItems);
      R__insp.InspectMember("TGFileBrowser::sLTI_t", (void*)&fSortedItems, "fSortedItems.", false);
      TGMainFrame::ShowMembers(R__insp);
      TBrowserImp::ShowMembers(R__insp);
}

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

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

   TNamed::Streamer(R__b);
}

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

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

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

   TGMainFrame::Streamer(R__b);
   TBrowserImp::Streamer(R__b);
}

//______________________________________________________________________________
void TRootBrowser::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRootBrowser.
      TClass *R__cl = ::TRootBrowser::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH0", &fLH0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH1", &fLH1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH2", &fLH2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH3", &fLH3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH4", &fLH4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH5", &fLH5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH6", &fLH6);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLH7", &fLH7);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabLeft", &fTabLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabRight", &fTabRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabBottom", &fTabBottom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditTab", &fEditTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditPos", &fEditPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditSubPos", &fEditSubPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVf", &fVf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHf", &fHf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fH1", &fH1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fH2", &fH2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV1", &fV1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV2", &fV2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVSplitter", &fVSplitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHSplitter", &fHSplitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditFrame", &fEditFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopMenuFrame", &fTopMenuFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreMenuFrame", &fPreMenuFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuFrame", &fMenuFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolbarFrame", &fToolbarFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuFile", &fMenuFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuExecPlugin", &fMenuExecPlugin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHelp", &fMenuHelp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActMenuBar", &fActMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActBrowser", &fActBrowser);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBrowsers", &fBrowsers);
      R__insp.InspectMember(fBrowsers, "fBrowsers.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlugins", &fPlugins);
      R__insp.InspectMember(fPlugins, "fPlugins.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBar", &fStatusBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbInitPlugins", &fNbInitPlugins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbTab[3]", fNbTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCrTab[3]", fCrTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPid", &fPid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowCloseTab", &fShowCloseTab);
      TGMainFrame::ShowMembers(R__insp);
      TBrowserImp::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRootBrowser(void *p) {
      return  p ? new(p) ::TRootBrowser : new ::TRootBrowser;
   }
   static void *newArray_TRootBrowser(Long_t nElements, void *p) {
      return p ? new(p) ::TRootBrowser[nElements] : new ::TRootBrowser[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRootBrowser(void *p) {
      delete ((::TRootBrowser*)p);
   }
   static void deleteArray_TRootBrowser(void *p) {
      delete [] ((::TRootBrowser*)p);
   }
   static void destruct_TRootBrowser(void *p) {
      typedef ::TRootBrowser current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRootBrowser(TBuffer &buf, void *obj) {
      ((::TRootBrowser*)obj)->::TRootBrowser::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRootBrowser

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGSplitFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGSplitFrame.
      TClass *R__cl = ::TGSplitFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndocked", &fUndocked);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplitter", &fSplitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSecond", &fSecond);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplitTool", &fSplitTool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWRatio", &fWRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHRatio", &fHRatio);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGSplitFrame(void *p) {
      return  p ? new(p) ::TGSplitFrame : new ::TGSplitFrame;
   }
   static void *newArray_TGSplitFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGSplitFrame[nElements] : new ::TGSplitFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGSplitFrame(void *p) {
      delete ((::TGSplitFrame*)p);
   }
   static void deleteArray_TGSplitFrame(void *p) {
      delete [] ((::TGSplitFrame*)p);
   }
   static void destruct_TGSplitFrame(void *p) {
      typedef ::TGSplitFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGSplitFrame(TBuffer &buf, void *obj) {
      ((::TGSplitFrame*)obj)->::TGSplitFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGSplitFrame

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGSplitTool::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGSplitTool.
      TClass *R__cl = ::TGSplitTool::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWindow", &fWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRectGC", &fRectGC);
      R__insp.InspectMember(fRectGC, "fRectGC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMap", &fMap);
      R__insp.InspectMember(fMap, "fMap.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContextMenu", &fContextMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGSplitTool(void *p) {
      return  p ? new(p) ::TGSplitTool : new ::TGSplitTool;
   }
   static void *newArray_TGSplitTool(Long_t nElements, void *p) {
      return p ? new(p) ::TGSplitTool[nElements] : new ::TGSplitTool[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGSplitTool(void *p) {
      delete ((::TGSplitTool*)p);
   }
   static void deleteArray_TGSplitTool(void *p) {
      delete [] ((::TGSplitTool*)p);
   }
   static void destruct_TGSplitTool(void *p) {
      typedef ::TGSplitTool current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGSplitTool(TBuffer &buf, void *obj) {
      ((::TGSplitTool*)obj)->::TGSplitTool::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGSplitTool

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

   TObject::Streamer(R__b);
}

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGShapedFrame(void *p) {
      return  p ? new(p) ::TGShapedFrame : new ::TGShapedFrame;
   }
   static void *newArray_TGShapedFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGShapedFrame[nElements] : new ::TGShapedFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGShapedFrame(void *p) {
      delete ((::TGShapedFrame*)p);
   }
   static void deleteArray_TGShapedFrame(void *p) {
      delete [] ((::TGShapedFrame*)p);
   }
   static void destruct_TGShapedFrame(void *p) {
      typedef ::TGShapedFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGShapedFrame(TBuffer &buf, void *obj) {
      ((::TGShapedFrame*)obj)->::TGShapedFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGShapedFrame

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

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

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

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

/********************************************************
* gui/gui/src/G__Gui3.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__Gui3();

extern "C" void G__set_cpp_environmentG__Gui3() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TRootGuiFactory.h");
  G__add_compiledheader("TRootApplication.h");
  G__add_compiledheader("TRootCanvas.h");
  G__add_compiledheader("TRootBrowserLite.h");
  G__add_compiledheader("TRootContextMenu.h");
  G__add_compiledheader("TRootDialog.h");
  G__add_compiledheader("TRootControlBar.h");
  G__add_compiledheader("TRootHelpDialog.h");
  G__add_compiledheader("TRootEmbeddedCanvas.h");
  G__add_compiledheader("TGColorDialog.h");
  G__add_compiledheader("TGColorSelect.h");
  G__add_compiledheader("TGFontDialog.h");
  G__add_compiledheader("TGDockableFrame.h");
  G__add_compiledheader("TGMdi.h");
  G__add_compiledheader("TGMdiFrame.h");
  G__add_compiledheader("TGMdiMainFrame.h");
  G__add_compiledheader("TGMdiDecorFrame.h");
  G__add_compiledheader("TGMdiMenu.h");
  G__add_compiledheader("TVirtualDragManager.h");
  G__add_compiledheader("TGuiBuilder.h");
  G__add_compiledheader("TGRedirectOutputGuard.h");
  G__add_compiledheader("TGPasswdDialog.h");
  G__add_compiledheader("TGTextEditor.h");
  G__add_compiledheader("TGSpeedo.h");
  G__add_compiledheader("TGDNDManager.h");
  G__add_compiledheader("TGTable.h");
  G__add_compiledheader("TGSimpleTableInterface.h");
  G__add_compiledheader("TGSimpleTable.h");
  G__add_compiledheader("TGTableCell.h");
  G__add_compiledheader("TGTableHeader.h");
  G__add_compiledheader("TGTableContainer.h");
  G__add_compiledheader("TGTextEditor.h");
  G__add_compiledheader("TGSpeedo.h");
  G__add_compiledheader("TGDNDManager.h");
  G__add_compiledheader("TGCommandPlugin.h");
  G__add_compiledheader("TGFileBrowser.h");
  G__add_compiledheader("TRootBrowser.h");
  G__add_compiledheader("TGSplitFrame.h");
  G__add_compiledheader("TGShapedFrame.h");
  G__add_compiledheader("TGEventHandler.h");
  G__cpp_reset_tagtableG__Gui3();
}
#include <new>
extern "C" int G__cpp_dllrevG__Gui3() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

static int G__G__Gui3_242_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDNDManager*) G__getstructoffset())->SetDragPixmap((Pixmap_t) G__int(libp->para[0]), (Pixmap_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__Gui3_242_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGDNDManager*) G__getstructoffset())->SetRootProxy());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui3_242_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TGDNDManager*) G__getstructoffset())->StartDrag((TGFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Window_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TGDNDManager*) G__getstructoffset())->StartDrag((TGFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGDNDManager*) G__getstructoffset())->Drag((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Atom_t) G__int(libp->para[2]), (Time_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Gui3_242_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDAware());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDProxy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDEnter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDLeave());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDDrop());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDFinished());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionCopy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionMove());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionLink());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionAsk());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionPrivate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDTypeList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetDNDActionDescrip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_242_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGDNDManager::GetXCDNDData());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Gui3_244_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRootCanvas* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRootCanvas(
(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) TRootCanvas(
(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__Gui3LN_TRootCanvas));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Gui3_256_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRootBrowserLite* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRootBrowserLite(
(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) TRootBrowserLite(
(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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui3_256_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowserLite*) G__getstructoffset())->AddToBox((TObject*) 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__Gui3_256_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TRootBrowserLite*) G__getstructoffset())->AddToTree((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:
      ((TRootBrowserLite*) G__getstructoffset())->AddToTree((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui3_256_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowserLite*) G__getstructoffset())->Checked((TObject*) 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__Gui3_256_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowserLite*) G__getstructoffset())->ResizeBrowser();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Gui3_256_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) TRootBrowserLite::NewBrowser((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) TRootBrowserLite::NewBrowser((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;
   case 3:
      G__letint(result7, 85, (long) TRootBrowserLite::NewBrowser((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TRootBrowserLite::NewBrowser((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TRootBrowserLite::NewBrowser((TBrowser*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TRootBrowserLite::NewBrowser());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_256_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) TRootBrowserLite::NewBrowser(
(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) TRootBrowserLite::NewBrowser((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__Gui3_256_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRootBrowserLite::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TGColorDialog G__TTGColorDialog;
static int G__G__Gui3_290_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGColorDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGColorDialog*) (soff+(sizeof(TGColorDialog)*i)))->~G__TTGColorDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGColorDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGColorDialog*) (soff))->~G__TTGColorDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGColorFrame */
static int G__G__Gui3_296_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGColorFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorFrame(
(TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGColorFrame(
(TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorFrame((TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGColorFrame((TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGColorFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGColorFrame[n];
       } else {
         p = new((void*) gvp) TGColorFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGColorFrame;
       } else {
         p = new((void*) gvp) TGColorFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorFrame*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGColorFrame*) G__getstructoffset())->GetColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGColorFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGColorFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGColorFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColorFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_296_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColorFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGColorFrame G__TTGColorFrame;
static int G__G__Gui3_296_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGColorFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGColorFrame*) (soff+(sizeof(TGColorFrame)*i)))->~G__TTGColorFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGColorFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGColorFrame*) (soff))->~G__TTGColorFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TG16ColorSelector */
static int G__G__Gui3_297_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TG16ColorSelector* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TG16ColorSelector((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TG16ColorSelector((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TG16ColorSelector[n];
       } else {
         p = new((void*) gvp) TG16ColorSelector[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TG16ColorSelector;
       } else {
         p = new((void*) gvp) TG16ColorSelector;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TG16ColorSelector*) G__getstructoffset())->SetActive((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TG16ColorSelector*) G__getstructoffset())->GetActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TG16ColorSelector::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TG16ColorSelector::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TG16ColorSelector::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TG16ColorSelector::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TG16ColorSelector*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TG16ColorSelector::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TG16ColorSelector::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TG16ColorSelector::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_297_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TG16ColorSelector::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TG16ColorSelector G__TTG16ColorSelector;
static int G__G__Gui3_297_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TG16ColorSelector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TG16ColorSelector*) (soff+(sizeof(TG16ColorSelector)*i)))->~G__TTG16ColorSelector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TG16ColorSelector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TG16ColorSelector*) (soff))->~G__TTG16ColorSelector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGColorPopup */
static int G__G__Gui3_298_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGColorPopup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorPopup(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGColorPopup(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorPopup((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGColorPopup((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorPopup((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGColorPopup((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGColorPopup[n];
       } else {
         p = new((void*) gvp) TGColorPopup[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGColorPopup;
       } else {
         p = new((void*) gvp) TGColorPopup;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorPopup*) G__getstructoffset())->PlacePopup((Int_t) G__int(libp->para[0]), (Int_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__Gui3_298_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorPopup*) G__getstructoffset())->EndPopup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorPopup*) G__getstructoffset())->PreviewColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGColorPopup::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorPopup::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGColorPopup::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGColorPopup::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorPopup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorPopup::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColorPopup::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorPopup::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_298_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColorPopup::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGColorPopup G__TTGColorPopup;
static int G__G__Gui3_298_0_21(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[] (TGColorPopup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGColorPopup*) (soff+(sizeof(TGColorPopup)*i)))->~G__TTGColorPopup();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGColorPopup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGColorPopup*) (soff))->~G__TTGColorPopup();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGColorSelect */
static int G__G__Gui3_299_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGColorSelect* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorSelect(
(TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGColorSelect(
(TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorSelect((TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGColorSelect((TGWindow*) G__int(libp->para[0]), (Pixel_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColorSelect((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGColorSelect((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGColorSelect[n];
       } else {
         p = new((void*) gvp) TGColorSelect[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGColorSelect;
       } else {
         p = new((void*) gvp) TGColorSelect;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGColorSelect*) G__getstructoffset())->SetColor((Pixel_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGColorSelect*) G__getstructoffset())->SetColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGColorSelect*) G__getstructoffset())->GetColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGColorSelect*) G__getstructoffset())->Enable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGColorSelect*) G__getstructoffset())->Enable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorSelect*) G__getstructoffset())->Disable();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorSelect*) G__getstructoffset())->Rename((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGColorSelect*) G__getstructoffset())->ColorSelected((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGColorSelect*) G__getstructoffset())->ColorSelected();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGColorSelect::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorSelect::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGColorSelect::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGColorSelect::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColorSelect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorSelect::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColorSelect::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColorSelect::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_299_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColorSelect::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGColorSelect G__TTGColorSelect;
static int G__G__Gui3_299_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[] (TGColorSelect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGColorSelect*) (soff+(sizeof(TGColorSelect)*i)))->~G__TTGColorSelect();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGColorSelect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGColorSelect*) (soff))->~G__TTGColorSelect();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFontDialog */
static int G__G__Gui3_301_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFontDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref
, (char**) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref
, (char**) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref
, (char**) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref
, (char**) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref);
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFontDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGFontDialog::FontProp_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFontDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFontDialog((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFontDialog[n];
       } else {
         p = new((void*) gvp) TGFontDialog[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFontDialog;
       } else {
         p = new((void*) gvp) TGFontDialog;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->SetFont((TGFont*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->SetColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->SetAlign((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGFontDialog*) G__getstructoffset())->EnableAlign((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGFontDialog*) G__getstructoffset())->EnableAlign();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->UpdateStyleSize((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->FontSelected((char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->AlignSelected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->ColorSelected((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFontDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFontDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFontDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFontDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFontDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFontDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFontDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_301_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFontDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFontDialog G__TTGFontDialog;
static int G__G__Gui3_301_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGFontDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFontDialog*) (soff+(sizeof(TGFontDialog)*i)))->~G__TTGFontDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFontDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFontDialog*) (soff))->~G__TTGFontDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFontDialog::FontProp_t */
// automatic default constructor
static int G__G__Gui3_302_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFontDialog::FontProp_t *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog::FontProp_t[n];
     } else {
       p = new((void*) gvp) TGFontDialog::FontProp_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontDialog::FontProp_t;
     } else {
       p = new((void*) gvp) TGFontDialog::FontProp_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_302_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGFontDialog::FontProp_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGFontDialog::FontProp_t(*(TGFontDialog::FontProp_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFontDialog::FontProp_t G__TTGFontDialogcLcLFontProp_t;
static int G__G__Gui3_302_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[] (TGFontDialog::FontProp_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFontDialog::FontProp_t*) (soff+(sizeof(TGFontDialog::FontProp_t)*i)))->~G__TTGFontDialogcLcLFontProp_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFontDialog::FontProp_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFontDialog::FontProp_t*) (soff))->~G__TTGFontDialogcLcLFontProp_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_302_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFontDialog::FontProp_t* dest = (TGFontDialog::FontProp_t*) G__getstructoffset();
   *dest = *(TGFontDialog::FontProp_t*) libp->para[0].ref;
   const TGFontDialog::FontProp_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDockButton */
static int G__G__Gui3_303_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDockButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDockButton((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGDockButton((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDockButton((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGDockButton((TGCompositeFrame*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDockButton[n];
       } else {
         p = new((void*) gvp) TGDockButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDockButton;
       } else {
         p = new((void*) gvp) TGDockButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDockButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDockButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDockButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDockButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDockButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDockButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDockButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDockButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_303_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDockButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDockButton G__TTGDockButton;
static int G__G__Gui3_303_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGDockButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDockButton*) (soff+(sizeof(TGDockButton)*i)))->~G__TTGDockButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDockButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDockButton*) (soff))->~G__TTGDockButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDockHideButton */
static int G__G__Gui3_304_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDockHideButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDockHideButton((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGDockHideButton((TGCompositeFrame*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDockHideButton[n];
       } else {
         p = new((void*) gvp) TGDockHideButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDockHideButton;
       } else {
         p = new((void*) gvp) TGDockHideButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDockHideButton*) G__getstructoffset())->SetAspectRatio((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDockHideButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDockHideButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDockHideButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDockHideButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDockHideButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDockHideButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDockHideButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDockHideButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_304_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDockHideButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDockHideButton G__TTGDockHideButton;
static int G__G__Gui3_304_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGDockHideButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDockHideButton*) (soff+(sizeof(TGDockHideButton)*i)))->~G__TTGDockHideButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDockHideButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDockHideButton*) (soff))->~G__TTGDockHideButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGUndockedFrame */
static int G__G__Gui3_305_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGUndockedFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGUndockedFrame((TGWindow*) G__int(libp->para[0]), (TGDockableFrame*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGUndockedFrame((TGWindow*) G__int(libp->para[0]), (TGDockableFrame*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGUndockedFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGUndockedFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGUndockedFrame[n];
       } else {
         p = new((void*) gvp) TGUndockedFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGUndockedFrame;
       } else {
         p = new((void*) gvp) TGUndockedFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGUndockedFrame*) G__getstructoffset())->FixSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGUndockedFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGUndockedFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGUndockedFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGUndockedFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGUndockedFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGUndockedFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGUndockedFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGUndockedFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_305_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGUndockedFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGUndockedFrame G__TTGUndockedFrame;
static int G__G__Gui3_305_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGUndockedFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGUndockedFrame*) (soff+(sizeof(TGUndockedFrame)*i)))->~G__TTGUndockedFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGUndockedFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGUndockedFrame*) (soff))->~G__TTGUndockedFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiMenuBar */
static int G__G__Gui3_310_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiMenuBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiMenuBar(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMdiMenuBar(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiMenuBar((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGMdiMenuBar((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiMenuBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGMdiMenuBar((TGWindow*) 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__Gui3LN_TGMdiMenuBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMenuBar*) G__getstructoffset())->AddPopup((TGHotString*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGLayoutHints*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiMenuBar*) G__getstructoffset())->GetMenuBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiMenuBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiMenuBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiMenuBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiMenuBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMenuBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiMenuBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiMenuBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiMenuBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_310_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiMenuBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiMenuBar G__TTGMdiMenuBar;
static int G__G__Gui3_310_0_21(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[] (TGMdiMenuBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiMenuBar*) (soff+(sizeof(TGMdiMenuBar)*i)))->~G__TTGMdiMenuBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiMenuBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiMenuBar*) (soff))->~G__TTGMdiMenuBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiContainer */
static int G__G__Gui3_311_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiContainer(
(TGMdiMainFrame*) 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])
, (ULong_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiContainer(
(TGMdiMainFrame*) 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])
, (ULong_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiContainer(
(TGMdiMainFrame*) 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]));
     } else {
       p = new((void*) gvp) TGMdiContainer(
(TGMdiMainFrame*) 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:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiContainer(
(TGMdiMainFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMdiContainer(
(TGMdiMainFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiContainer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiContainer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiContainer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiContainer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiContainer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiContainer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiContainer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiContainer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_311_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiContainer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiContainer G__TTGMdiContainer;
static int G__G__Gui3_311_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiContainer*) (soff+(sizeof(TGMdiContainer)*i)))->~G__TTGMdiContainer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiContainer*) (soff))->~G__TTGMdiContainer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiDecorFrame */
static int G__G__Gui3_312_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiDecorFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiDecorFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (TGMdiFrame*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGGC*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGMdiDecorFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (TGMdiFrame*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGGC*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiDecorFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (TGMdiFrame*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGGC*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMdiDecorFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (TGMdiFrame*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGGC*) 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 TGMdiDecorFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (TGMdiFrame*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGGC*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiDecorFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (TGMdiFrame*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGGC*) 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__Gui3LN_TGMdiDecorFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGMdiDecorFrame*) G__getstructoffset())->CloseWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetMdiButtons((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetMdiButtons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiDecorFrame*) G__getstructoffset())->SetResizeMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiDecorFrame*) G__getstructoffset())->SetResizeMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetWindowIcon((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGMdiDecorFrame*) G__getstructoffset())->GetWindowName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGMdiDecorFrame*) G__getstructoffset())->GetWindowIcon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->IsCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->IsMinimized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->IsMaximized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetPreResizeX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetPreResizeY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetPreResizeWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetPreResizeHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetMinimizedX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetMinimizedY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetMinUserPlacement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiDecorFrame*) G__getstructoffset())->SetCurrent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiDecorFrame*) G__getstructoffset())->SetCurrent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetDecorBorderWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetPreResizeX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetPreResizeY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetPreResizeWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetPreResizeHeight((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetMinimizedX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->SetMinimizedY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiDecorFrame*) G__getstructoffset())->Minimize((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiDecorFrame*) G__getstructoffset())->Minimize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiDecorFrame*) G__getstructoffset())->Maximize((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiDecorFrame*) G__getstructoffset())->Maximize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiDecorFrame*) G__getstructoffset())->SetMinUserPlacement((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiDecorFrame*) G__getstructoffset())->SetMinUserPlacement();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetMdiFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetTitleBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetUpperHR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetLowerHR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetUpperLeftCR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetLowerLeftCR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetUpperRightCR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetLowerRightCR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetLeftVR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiDecorFrame*) G__getstructoffset())->GetRightVR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiDecorFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiDecorFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiDecorFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiDecorFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiDecorFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiDecorFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiDecorFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiDecorFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_312_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiDecorFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiDecorFrame G__TTGMdiDecorFrame;
static int G__G__Gui3_312_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiDecorFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiDecorFrame*) (soff+(sizeof(TGMdiDecorFrame)*i)))->~G__TTGMdiDecorFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiDecorFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiDecorFrame*) (soff))->~G__TTGMdiDecorFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiFrame */
static int G__G__Gui3_313_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiFrame(
(TGMdiMainFrame*) 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])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiFrame(
(TGMdiMainFrame*) 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])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiFrame(
(TGMdiMainFrame*) 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]));
     } else {
       p = new((void*) gvp) TGMdiFrame(
(TGMdiMainFrame*) 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:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMdiFrame(
(TGMdiMainFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiFrame*) G__getstructoffset())->CloseWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiFrame*) G__getstructoffset())->Help());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrame*) G__getstructoffset())->SetMdiHints((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGMdiFrame*) G__getstructoffset())->GetMdiHints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrame*) G__getstructoffset())->DontCallClose();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrame*) G__getstructoffset())->SetWindowIcon((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGMdiFrame*) G__getstructoffset())->GetWindowName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGMdiFrame*) G__getstructoffset())->GetWindowIcon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_313_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiFrame G__TTGMdiFrame;
static int G__G__Gui3_313_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiFrame*) (soff+(sizeof(TGMdiFrame)*i)))->~G__TTGMdiFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiFrame*) (soff))->~G__TTGMdiFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiFrameList */
static int G__G__Gui3_314_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGMdiFrameList*) G__getstructoffset())->GetFrameId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiFrameList*) G__getstructoffset())->GetDecorFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiFrameList*) G__getstructoffset())->GetPrev());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiFrameList*) G__getstructoffset())->GetNext());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiFrameList*) G__getstructoffset())->GetCyclePrev());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiFrameList*) G__getstructoffset())->GetCycleNext());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->SetFrameId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->SetDecorFrame((TGMdiDecorFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->SetPrev((TGMdiFrameList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->SetNext((TGMdiFrameList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->SetCyclePrev((TGMdiFrameList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->SetCycleNext((TGMdiFrameList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiFrameList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiFrameList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiFrameList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiFrameList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiFrameList*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiFrameList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiFrameList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiFrameList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiFrameList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_314_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiFrameList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__G__Gui3_314_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiFrameList *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiFrameList[n];
     } else {
       p = new((void*) gvp) TGMdiFrameList[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiFrameList;
     } else {
       p = new((void*) gvp) TGMdiFrameList;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_314_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGMdiFrameList* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGMdiFrameList(*(TGMdiFrameList*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiFrameList G__TTGMdiFrameList;
static int G__G__Gui3_314_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[] (TGMdiFrameList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiFrameList*) (soff+(sizeof(TGMdiFrameList)*i)))->~G__TTGMdiFrameList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiFrameList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiFrameList*) (soff))->~G__TTGMdiFrameList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_314_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiFrameList* dest = (TGMdiFrameList*) G__getstructoffset();
   *dest = *(TGMdiFrameList*) libp->para[0].ref;
   const TGMdiFrameList& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiMainFrame */
static int G__G__Gui3_315_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiMainFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiMainFrame(
(TGWindow*) G__int(libp->para[0]), (TGMdiMenuBar*) 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]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMdiMainFrame(
(TGWindow*) G__int(libp->para[0]), (TGMdiMenuBar*) 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]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiMainFrame(
(TGWindow*) G__int(libp->para[0]), (TGMdiMenuBar*) 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]));
     } else {
       p = new((void*) gvp) TGMdiMainFrame(
(TGWindow*) G__int(libp->para[0]), (TGMdiMenuBar*) 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]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiMainFrame(
(TGWindow*) G__int(libp->para[0]), (TGMdiMenuBar*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGMdiMainFrame(
(TGWindow*) G__int(libp->para[0]), (TGMdiMenuBar*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FreeMove((TGMdiFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FreeSize((TGMdiFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->Restore((TGMdiFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->Maximize((TGMdiFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->Minimize((TGMdiFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGMdiMainFrame*) G__getstructoffset())->Close((TGMdiFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGMdiMainFrame*) G__getstructoffset())->ContextHelp((TGMdiFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->CloseAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->Cascade();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->TileHorizontal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->TileVertical();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->ArrangeFrames((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->ArrangeMinimized();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->CirculateUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->CirculateDown();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetMdiFrame((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiMainFrame*) G__getstructoffset())->SetCurrent((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiMainFrame*) G__getstructoffset())->SetCurrent((TGMdiFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetWinListMenu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetMenu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetWindowList((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetWindowList());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGMdiMainFrame*) G__getstructoffset())->GetNumberOfFrames());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiMainFrame*) G__getstructoffset())->SetResizeMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiMainFrame*) G__getstructoffset())->SetResizeMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRectangle* pobj;
         const TGRectangle xobj = ((const TGMdiMainFrame*) G__getstructoffset())->GetBBox();
         pobj = new TGRectangle(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__Gui3_315_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRectangle* pobj;
         const TGRectangle xobj = ((const TGMdiMainFrame*) G__getstructoffset())->GetMinimizedBBox();
         pobj = new TGRectangle(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__Gui3_315_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGMdiGeometry* pobj;
         const TGMdiGeometry xobj = ((const TGMdiMainFrame*) G__getstructoffset())->GetWindowGeometry((TGMdiFrame*) G__int(libp->para[0]));
         pobj = new TGMdiGeometry(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__Gui3_315_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->ConfigureWindow((TGMdiFrame*) G__int(libp->para[0]), *(TGMdiGeometry*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiMainFrame*) G__getstructoffset())->IsMaximized((TGMdiFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiMainFrame*) G__getstructoffset())->IsMinimized((TGMdiFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FrameCreated((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FrameClosed((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FrameMaximized((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FrameMinimized((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FrameRestored((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->FramesArranged((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiMainFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiMainFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiMainFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiMainFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiMainFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiMainFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiMainFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiMainFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_315_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiMainFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiMainFrame G__TTGMdiMainFrame;
static int G__G__Gui3_315_0_61(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[] (TGMdiMainFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiMainFrame*) (soff+(sizeof(TGMdiMainFrame)*i)))->~G__TTGMdiMainFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiMainFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiMainFrame*) (soff))->~G__TTGMdiMainFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiGeometry */
static int G__G__Gui3_316_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiGeometry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiGeometry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiGeometry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiGeometry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiGeometry*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiGeometry*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiGeometry*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiGeometry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiGeometry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiGeometry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiGeometry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_316_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiGeometry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__G__Gui3_316_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiGeometry *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiGeometry[n];
     } else {
       p = new((void*) gvp) TGMdiGeometry[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiGeometry;
     } else {
       p = new((void*) gvp) TGMdiGeometry;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_316_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGMdiGeometry* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGMdiGeometry(*(TGMdiGeometry*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiGeometry G__TTGMdiGeometry;
static int G__G__Gui3_316_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiGeometry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiGeometry*) (soff+(sizeof(TGMdiGeometry)*i)))->~G__TTGMdiGeometry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiGeometry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiGeometry*) (soff))->~G__TTGMdiGeometry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_316_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiGeometry* dest = (TGMdiGeometry*) G__getstructoffset();
   *dest = *(TGMdiGeometry*) libp->para[0].ref;
   const TGMdiGeometry& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiTitleIcon */
static int G__G__Gui3_318_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiTitleIcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGMdiTitleIcon(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGMdiTitleIcon(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiTitleIcon*) G__getstructoffset())->GetPopup());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiTitleIcon::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiTitleIcon::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiTitleIcon::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiTitleIcon::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiTitleIcon*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiTitleIcon::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiTitleIcon::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiTitleIcon::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_318_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiTitleIcon::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiTitleIcon G__TTGMdiTitleIcon;
static int G__G__Gui3_318_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiTitleIcon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiTitleIcon*) (soff+(sizeof(TGMdiTitleIcon)*i)))->~G__TTGMdiTitleIcon();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiTitleIcon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiTitleIcon*) (soff))->~G__TTGMdiTitleIcon();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiButtons */
static int G__G__Gui3_319_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiButtons* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGMdiButtons((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGMdiButtons((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiButtons*) G__getstructoffset())->GetButton((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiButtons::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiButtons::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiButtons::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiButtons::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiButtons*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiButtons::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiButtons::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiButtons::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_319_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiButtons::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiButtons G__TTGMdiButtons;
static int G__G__Gui3_319_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiButtons*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiButtons*) (soff+(sizeof(TGMdiButtons)*i)))->~G__TTGMdiButtons();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiButtons*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiButtons*) (soff))->~G__TTGMdiButtons();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiTitleBar */
static int G__G__Gui3_325_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiTitleBar*) G__getstructoffset())->SetTitleBarColors((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (TGFont*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiTitleBar*) G__getstructoffset())->GetButtons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiTitleBar*) G__getstructoffset())->GetWinIcon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMdiTitleBar*) G__getstructoffset())->GetWinName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGMdiTitleBar*) G__getstructoffset())->GetX0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGMdiTitleBar*) G__getstructoffset())->GetY0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiTitleBar*) G__getstructoffset())->IsLeftButPressed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiTitleBar*) G__getstructoffset())->IsRightButPressed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMdiTitleBar*) G__getstructoffset())->IsMidButPressed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiTitleBar*) G__getstructoffset())->SetX0((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiTitleBar*) G__getstructoffset())->SetY0((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiTitleBar*) G__getstructoffset())->SetLeftButPressed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiTitleBar*) G__getstructoffset())->SetLeftButPressed();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiTitleBar*) G__getstructoffset())->SetRightButPressed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiTitleBar*) G__getstructoffset())->SetRightButPressed();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGMdiTitleBar*) G__getstructoffset())->SetMidButPressed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiTitleBar*) G__getstructoffset())->SetMidButPressed();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiTitleBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiTitleBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiTitleBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiTitleBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiTitleBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiTitleBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiTitleBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiTitleBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_325_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiTitleBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiTitleBar G__TTGMdiTitleBar;
static int G__G__Gui3_325_0_35(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[] (TGMdiTitleBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiTitleBar*) (soff+(sizeof(TGMdiTitleBar)*i)))->~G__TTGMdiTitleBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiTitleBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiTitleBar*) (soff))->~G__TTGMdiTitleBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiWinResizer */
static int G__G__Gui3_326_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiWinResizer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     } else {
       p = new((void*) gvp) TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_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__Gui3LN_TGMdiWinResizer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiWinResizer*) G__getstructoffset())->SetResizeMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGMdiWinResizer*) G__getstructoffset())->SetMinSize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGMdiWinResizer*) G__getstructoffset())->SetMinSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMdiWinResizer*) G__getstructoffset())->SetMinSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiWinResizer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiWinResizer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiWinResizer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiWinResizer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiWinResizer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiWinResizer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiWinResizer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiWinResizer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_326_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiWinResizer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiWinResizer G__TTGMdiWinResizer;
static int G__G__Gui3_326_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiWinResizer*) (soff+(sizeof(TGMdiWinResizer)*i)))->~G__TTGMdiWinResizer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiWinResizer*) (soff))->~G__TTGMdiWinResizer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiVerticalWinResizer */
static int G__G__Gui3_327_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiVerticalWinResizer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     } else {
       p = new((void*) gvp) TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiVerticalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_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__Gui3LN_TGMdiVerticalWinResizer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiVerticalWinResizer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiVerticalWinResizer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiVerticalWinResizer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiVerticalWinResizer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiVerticalWinResizer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiVerticalWinResizer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiVerticalWinResizer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiVerticalWinResizer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_327_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiVerticalWinResizer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiVerticalWinResizer G__TTGMdiVerticalWinResizer;
static int G__G__Gui3_327_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiVerticalWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiVerticalWinResizer*) (soff+(sizeof(TGMdiVerticalWinResizer)*i)))->~G__TTGMdiVerticalWinResizer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiVerticalWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiVerticalWinResizer*) (soff))->~G__TTGMdiVerticalWinResizer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiHorizontalWinResizer */
static int G__G__Gui3_328_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiHorizontalWinResizer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     } else {
       p = new((void*) gvp) TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiHorizontalWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_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__Gui3LN_TGMdiHorizontalWinResizer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiHorizontalWinResizer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiHorizontalWinResizer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiHorizontalWinResizer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiHorizontalWinResizer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiHorizontalWinResizer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiHorizontalWinResizer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiHorizontalWinResizer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiHorizontalWinResizer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_328_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiHorizontalWinResizer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiHorizontalWinResizer G__TTGMdiHorizontalWinResizer;
static int G__G__Gui3_328_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiHorizontalWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiHorizontalWinResizer*) (soff+(sizeof(TGMdiHorizontalWinResizer)*i)))->~G__TTGMdiHorizontalWinResizer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiHorizontalWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiHorizontalWinResizer*) (soff))->~G__TTGMdiHorizontalWinResizer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMdiCornerWinResizer */
static int G__G__Gui3_329_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMdiCornerWinResizer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     } else {
       p = new((void*) gvp) TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) 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]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMdiCornerWinResizer(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGGC*) G__int(libp->para[3])
, (Int_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__Gui3LN_TGMdiCornerWinResizer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMdiCornerWinResizer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiCornerWinResizer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMdiCornerWinResizer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMdiCornerWinResizer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMdiCornerWinResizer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiCornerWinResizer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiCornerWinResizer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMdiCornerWinResizer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_329_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMdiCornerWinResizer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMdiCornerWinResizer G__TTGMdiCornerWinResizer;
static int G__G__Gui3_329_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGMdiCornerWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMdiCornerWinResizer*) (soff+(sizeof(TGMdiCornerWinResizer)*i)))->~G__TTGMdiCornerWinResizer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMdiCornerWinResizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMdiCornerWinResizer*) (soff))->~G__TTGMdiCornerWinResizer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualDragManager */
static int G__G__Gui3_332_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualDragManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVirtualDragManager[n];
     } else {
       p = new((void*) gvp) TVirtualDragManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVirtualDragManager;
     } else {
       p = new((void*) gvp) TVirtualDragManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetDragType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualDragManager*) G__getstructoffset())->IsMoveWaiting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualDragManager*) G__getstructoffset())->IsDragging());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualDragManager*) G__getstructoffset())->IsDropping());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualDragManager*) G__getstructoffset())->IsPasting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetSource());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetFrameUnder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetPasteFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->SetTarget((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->SetSource((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->SetPasteFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->StartDrag((TGFrame*) 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, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->StartDrag((TGFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->StartDrag((TGFrame*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->StartDrag());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->EndDrag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->Drop());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->Cancel((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->Cancel());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->HandleEvent((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->HandleTimerEvent((Event_t*) G__int(libp->para[0]), (TTimer*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualDragManager*) G__getstructoffset())->IgnoreEvent((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->SetEditable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetStrartDragX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetStrartDragY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetEndDragX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualDragManager*) G__getstructoffset())->GetEndDragY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualDragManager::Instance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualDragManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualDragManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualDragManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualDragManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualDragManager*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualDragManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualDragManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualDragManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualDragManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_332_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualDragManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_332_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TVirtualDragManager* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TVirtualDragManager(*(TVirtualDragManager*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualDragManager G__TTVirtualDragManager;
static int G__G__Gui3_332_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[] (TVirtualDragManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualDragManager*) (soff+(sizeof(TVirtualDragManager)*i)))->~G__TTVirtualDragManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualDragManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualDragManager*) (soff))->~G__TTVirtualDragManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_332_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualDragManager* dest = (TVirtualDragManager*) G__getstructoffset();
   *dest = *(TVirtualDragManager*) libp->para[0].ref;
   const TVirtualDragManager& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGuiBldAction */
static int G__G__Gui3_334_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGuiBldAction* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGuiBldAction(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGLayoutHints*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGuiBldAction(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGLayoutHints*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGuiBldAction(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGuiBldAction(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGuiBldAction((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGuiBldAction((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 TGuiBldAction((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGuiBldAction((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 TGuiBldAction[n];
       } else {
         p = new((void*) gvp) TGuiBldAction[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGuiBldAction;
       } else {
         p = new((void*) gvp) TGuiBldAction;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGuiBldAction::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiBldAction::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGuiBldAction::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGuiBldAction::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBldAction*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiBldAction::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGuiBldAction::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiBldAction::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_334_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGuiBldAction::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_334_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGuiBldAction* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGuiBldAction(*(TGuiBldAction*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGuiBldAction G__TTGuiBldAction;
static int G__G__Gui3_334_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGuiBldAction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGuiBldAction*) (soff+(sizeof(TGuiBldAction)*i)))->~G__TTGuiBldAction();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGuiBldAction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGuiBldAction*) (soff))->~G__TTGuiBldAction();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGuiBuilder */
static int G__G__Gui3_335_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGuiBuilder* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGuiBuilder[n];
     } else {
       p = new((void*) gvp) TGuiBuilder[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGuiBuilder;
     } else {
       p = new((void*) gvp) TGuiBuilder;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->AddAction((TGuiBldAction*) 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__Gui3_335_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->AddSection((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGuiBuilder*) G__getstructoffset())->ExecuteAction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->SetAction((TGuiBldAction*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGuiBuilder*) G__getstructoffset())->GetAction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGuiBuilder*) G__getstructoffset())->IsExecutable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGuiBuilder::Instance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGuiBuilder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiBuilder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGuiBuilder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGuiBuilder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGuiBuilder*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGuiBuilder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiBuilder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGuiBuilder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGuiBuilder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_335_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGuiBuilder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_335_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGuiBuilder* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGuiBuilder(*(TGuiBuilder*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGuiBuilder G__TTGuiBuilder;
static int G__G__Gui3_335_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGuiBuilder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGuiBuilder*) (soff+(sizeof(TGuiBuilder)*i)))->~G__TTGuiBuilder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGuiBuilder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGuiBuilder*) (soff))->~G__TTGuiBuilder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_335_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGuiBuilder* dest = (TGuiBuilder*) G__getstructoffset();
   *dest = *(TGuiBuilder*) libp->para[0].ref;
   const TGuiBuilder& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRedirectOutputGuard */
static int G__G__Gui3_336_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRedirectOutputGuard* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRedirectOutputGuard(
(TGTextView*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRedirectOutputGuard(
(TGTextView*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRedirectOutputGuard((TGTextView*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGRedirectOutputGuard((TGTextView*) 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 TGRedirectOutputGuard((TGTextView*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGRedirectOutputGuard((TGTextView*) 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__Gui3LN_TGRedirectOutputGuard));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRedirectOutputGuard*) G__getstructoffset())->Update();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRedirectOutputGuard::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRedirectOutputGuard::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRedirectOutputGuard::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRedirectOutputGuard::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGRedirectOutputGuard*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRedirectOutputGuard*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRedirectOutputGuard*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRedirectOutputGuard*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRedirectOutputGuard::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRedirectOutputGuard::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRedirectOutputGuard::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_336_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRedirectOutputGuard::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_336_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGRedirectOutputGuard* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGRedirectOutputGuard(*(TGRedirectOutputGuard*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGRedirectOutputGuard));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRedirectOutputGuard G__TTGRedirectOutputGuard;
static int G__G__Gui3_336_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[] (TGRedirectOutputGuard*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRedirectOutputGuard*) (soff+(sizeof(TGRedirectOutputGuard)*i)))->~G__TTGRedirectOutputGuard();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRedirectOutputGuard*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRedirectOutputGuard*) (soff))->~G__TTGRedirectOutputGuard();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_336_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRedirectOutputGuard* dest = (TGRedirectOutputGuard*) G__getstructoffset();
   *dest = *(TGRedirectOutputGuard*) libp->para[0].ref;
   const TGRedirectOutputGuard& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGPasswdDialog */
static int G__G__Gui3_338_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPasswdDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPasswdDialog(
(const char*) G__int(libp->para[0]), (char*) 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]));
     } else {
       p = new((void*) gvp) TGPasswdDialog(
(const char*) G__int(libp->para[0]), (char*) 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:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPasswdDialog(
(const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGPasswdDialog(
(const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (Int_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 TGPasswdDialog(
(const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPasswdDialog(
(const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPasswdDialog*) G__getstructoffset())->ReturnPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPasswdDialog*) G__getstructoffset())->CloseWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPasswdDialog*) G__getstructoffset())->DoClose();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGPasswdDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPasswdDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGPasswdDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGPasswdDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPasswdDialog*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPasswdDialog*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPasswdDialog*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPasswdDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPasswdDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPasswdDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPasswdDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_338_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPasswdDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_338_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGPasswdDialog* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGPasswdDialog(*(TGPasswdDialog*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGPasswdDialog G__TTGPasswdDialog;
static int G__G__Gui3_338_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[] (TGPasswdDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPasswdDialog*) (soff+(sizeof(TGPasswdDialog)*i)))->~G__TTGPasswdDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPasswdDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPasswdDialog*) (soff))->~G__TTGPasswdDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_338_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPasswdDialog* dest = (TGPasswdDialog*) G__getstructoffset();
   *dest = *(TGPasswdDialog*) libp->para[0].ref;
   const TGPasswdDialog& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextEditor */
static int G__G__Gui3_358_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEditor(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextEditor(
(const char*) G__int(libp->para[0]), (TGWindow*) 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 TGTextEditor(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextEditor(
(const char*) G__int(libp->para[0]), (TGWindow*) 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 TGTextEditor((const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextEditor((const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEditor((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextEditor((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 TGTextEditor[n];
       } else {
         p = new((void*) gvp) TGTextEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextEditor;
       } else {
         p = new((void*) gvp) TGTextEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEditor(
(TMacro*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextEditor(
(TMacro*) G__int(libp->para[0]), (TGWindow*) 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 TGTextEditor(
(TMacro*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextEditor(
(TMacro*) G__int(libp->para[0]), (TGWindow*) 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 TGTextEditor((TMacro*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextEditor((TMacro*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEditor((TMacro*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextEditor((TMacro*) 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__Gui3LN_TGTextEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->ClearText();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextEditor*) G__getstructoffset())->LoadBuffer((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEditor*) G__getstructoffset())->LoadFile((char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEditor*) G__getstructoffset())->LoadFile();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->SaveFile((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextEditor*) G__getstructoffset())->SaveFileAs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->PrintText();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->Search((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->Goto();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->About();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->DataChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->DataDropped((char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGTextEditor*) G__getstructoffset())->IsSaved());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->CompileMacro();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->ExecuteMacro();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->InterruptMacro();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->SetText((TGText*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->AddText((TGText*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->AddLine((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->AddLineFast((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextEditor*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_358_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextEditor G__TTGTextEditor;
static int G__G__Gui3_358_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[] (TGTextEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextEditor*) (soff+(sizeof(TGTextEditor)*i)))->~G__TTGTextEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextEditor*) (soff))->~G__TTGTextEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSpeedo */
static int G__G__Gui3_375_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSpeedo* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo((TGWindow*) G__int(libp->para[0]), (int) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGSpeedo((TGWindow*) G__int(libp->para[0]), (int) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGSpeedo((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSpeedo[n];
       } else {
         p = new((void*) gvp) TGSpeedo[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSpeedo;
       } else {
         p = new((void*) gvp) TGSpeedo;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSpeedo* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (int) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (int) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(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 TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGSpeedo(
(TGWindow*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSpeedo*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSpeedo*) G__getstructoffset())->GetImage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGSpeedo*) G__getstructoffset())->GetPeakVal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGSpeedo*) G__getstructoffset())->GetScaleMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGSpeedo*) G__getstructoffset())->GetScaleMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGSpeedo*) G__getstructoffset())->IsThresholdActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->Build();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGSpeedo*) G__getstructoffset())->Glow((TGSpeedo::EGlowColor) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSpeedo*) G__getstructoffset())->Glow();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->StepScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->SetScaleValue((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->SetScaleValue((Float_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->SetOdoValue((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGSpeedo*) G__getstructoffset())->SetDisplayText((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGSpeedo*) G__getstructoffset())->SetDisplayText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGSpeedo*) G__getstructoffset())->SetLabelText((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGSpeedo*) G__getstructoffset())->SetLabelText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->SetMinMaxScale((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__Gui3_375_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGSpeedo*) G__getstructoffset())->SetThresholds((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGSpeedo*) G__getstructoffset())->SetThresholds((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGSpeedo*) G__getstructoffset())->SetThresholds((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSpeedo*) G__getstructoffset())->SetThresholds();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->SetThresholdColors((TGSpeedo::EGlowColor) G__int(libp->para[0]), (TGSpeedo::EGlowColor) G__int(libp->para[1])
, (TGSpeedo::EGlowColor) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->EnableThreshold();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->DisableThreshold();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->EnablePeakMark();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->DisablePeakMark();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->EnableMeanMark();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->DisableMeanMark();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->ResetPeakVal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->SetMeanValue((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->OdoClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->LedClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSpeedo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSpeedo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSpeedo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSpeedo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSpeedo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSpeedo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSpeedo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSpeedo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_375_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSpeedo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSpeedo G__TTGSpeedo;
static int G__G__Gui3_375_0_48(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[] (TGSpeedo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSpeedo*) (soff+(sizeof(TGSpeedo)*i)))->~G__TTGSpeedo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSpeedo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSpeedo*) (soff))->~G__TTGSpeedo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDragWindow */
static int G__G__Gui3_377_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDragWindow* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDragWindow(
(TGWindow*) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1])
, (Pixmap_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGDragWindow(
(TGWindow*) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1])
, (Pixmap_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDragWindow(
(TGWindow*) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1])
, (Pixmap_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGDragWindow(
(TGWindow*) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1])
, (Pixmap_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 TGDragWindow(
(TGWindow*) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1])
, (Pixmap_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGDragWindow(
(TGWindow*) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1])
, (Pixmap_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGDragWindow*) G__getstructoffset())->GetInputId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGDragWindow*) G__getstructoffset())->HasWindow((Window_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDragWindow::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDragWindow::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDragWindow::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDragWindow::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDragWindow*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDragWindow::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDragWindow::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDragWindow::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_377_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDragWindow::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDragWindow G__TTGDragWindow;
static int G__G__Gui3_377_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[] (TGDragWindow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDragWindow*) (soff+(sizeof(TGDragWindow)*i)))->~G__TTGDragWindow();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDragWindow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDragWindow*) (soff))->~G__TTGDragWindow();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTable */
static int G__G__Gui3_378_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TVirtualTableInterface*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TVirtualTableInterface*) 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 TGTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TVirtualTableInterface*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TVirtualTableInterface*) 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 TGTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TVirtualTableInterface*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TVirtualTableInterface*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTable((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTable((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTable((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTable((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTable[n];
       } else {
         p = new((void*) gvp) TGTable[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTable;
       } else {
         p = new((void*) gvp) TGTable;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetRow((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetColumn((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTable*) G__getstructoffset())->GetCell((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetCell((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTable*) G__getstructoffset())->FindCell(*((TGString*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->FindCell(*((TGString*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->UpdateView();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTable*) G__getstructoffset())->GetNTableRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTable*) G__getstructoffset())->GetNDataRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTable*) G__getstructoffset())->GetNTableColumns());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTable*) G__getstructoffset())->GetNDataColumns());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTable*) G__getstructoffset())->GetNTableCells());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTable*) G__getstructoffset())->GetNDataCells());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTable*) G__getstructoffset())->GetCurrentRange());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetInterface());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetRHdrFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetCHdrFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTable*) G__getstructoffset())->GetRowHeader((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetRowHeader((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTable*) G__getstructoffset())->GetColumnHeader((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetColumnHeader((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->GetTableHeader());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTable*) G__getstructoffset())->GetRowBackground((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTable*) G__getstructoffset())->GetHeaderBackground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->SetOddRowBackground((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->SetEvenRowBackground((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->SetHeaderBackground((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->SetDefaultColors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->MoveTable((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__Gui3_378_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->GotoTableRange((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__Gui3_378_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTable*) G__getstructoffset())->operator()((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->ScrollCHeaders((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->ScrollRHeaders((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->NextChunk();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->PreviousChunk();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->UserRangeChange();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->Goto();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->Update();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_378_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTable G__TTGTable;
static int G__G__Gui3_378_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTable*) (soff+(sizeof(TGTable)*i)))->~G__TTGTable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTable*) (soff))->~G__TTGTable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTableCell */
static int G__G__Gui3_380_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGTableCell::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGTableCell::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableCell* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9])
, (Bool_t) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9])
, (Bool_t) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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]), (GContext_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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 TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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 TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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 TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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 TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell((TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTableCell((TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTableCell((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTableCell[n];
       } else {
         p = new((void*) gvp) TGTableCell[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTableCell;
       } else {
         p = new((void*) gvp) TGTableCell;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableCell* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9])
, (Bool_t) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9])
, (Bool_t) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (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 TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) 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 TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTableCell(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const 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__Gui3LN_TGTableCell));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SetLabel((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SetImage((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SetTextJustify((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SetFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SetFont((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->Select();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SelectRow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->SelectColumn();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTableCell*) G__getstructoffset())->GetColumn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTableCell*) G__getstructoffset())->GetRow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTableCell*) G__getstructoffset())->GetLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTableCell*) G__getstructoffset())->GetImage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTableCell*) G__getstructoffset())->GetTextJustify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTableCell::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableCell::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTableCell::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTableCell::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableCell*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableCell::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableCell::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableCell::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_380_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableCell::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTableCell G__TTGTableCell;
static int G__G__Gui3_380_0_42(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[] (TGTableCell*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTableCell*) (soff+(sizeof(TGTableCell)*i)))->~G__TTGTableCell();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTableCell*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTableCell*) (soff))->~G__TTGTableCell();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTableHeader */
static int G__G__Gui3_382_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableHeader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) 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 TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) 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 TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) 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 TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (TGString*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader((TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTableHeader((TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTableHeader((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTableHeader[n];
       } else {
         p = new((void*) gvp) TGTableHeader[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTableHeader;
       } else {
         p = new((void*) gvp) TGTableHeader;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableHeader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]), (UInt_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7])
, (FontStruct_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (GContext_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) 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 TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) 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 TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableHeader(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (const char*) 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__Gui3LN_TGTableHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableHeader*) G__getstructoffset())->SetDefaultLabel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableHeader*) G__getstructoffset())->SetPosition((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTableHeader*) G__getstructoffset())->Sort((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTableHeader*) G__getstructoffset())->Sort();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableHeader*) G__getstructoffset())->UpdatePosition();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGTableHeader*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTableHeader::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableHeader::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTableHeader::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTableHeader::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableHeader::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableHeader::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableHeader::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_382_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableHeader::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTableHeader G__TTGTableHeader;
static int G__G__Gui3_382_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGTableHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTableHeader*) (soff+(sizeof(TGTableHeader)*i)))->~G__TTGTableHeader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTableHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTableHeader*) (soff))->~G__TTGTableHeader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTableFrame */
static int G__G__Gui3_384_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGTableFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGTableFrame(
(TGWindow*) 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__Gui3LN_TGTableFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTableFrame*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableFrame*) G__getstructoffset())->SetCanvas((TGCanvas*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableFrame*) G__getstructoffset())->HandleMouseWheel((Event_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableFrame*) G__getstructoffset())->DrawRegion((Int_t) G__int(libp->para[0]), (Int_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__Gui3_384_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTableFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTableFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTableFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_384_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTableFrame G__TTGTableFrame;
static int G__G__Gui3_384_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[] (TGTableFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTableFrame*) (soff+(sizeof(TGTableFrame)*i)))->~G__TTGTableFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTableFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTableFrame*) (soff))->~G__TTGTableFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTableHeaderFrame */
static int G__G__Gui3_385_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableHeaderFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) 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 TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (EHeaderType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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 TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTableHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (TGTable*) 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 TGTableHeaderFrame((TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTableHeaderFrame((TGWindow*) G__int(libp->para[0]), (TGTable*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableHeaderFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTableHeaderFrame((TGWindow*) 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__Gui3LN_TGTableHeaderFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableHeaderFrame*) G__getstructoffset())->DrawRegion((Int_t) G__int(libp->para[0]), (Int_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__Gui3_385_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTableHeaderFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableHeaderFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTableHeaderFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTableHeaderFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableHeaderFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableHeaderFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableHeaderFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableHeaderFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_385_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableHeaderFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTableHeaderFrame G__TTGTableHeaderFrame;
static int G__G__Gui3_385_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGTableHeaderFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTableHeaderFrame*) (soff+(sizeof(TGTableHeaderFrame)*i)))->~G__TTGTableHeaderFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTableHeaderFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTableHeaderFrame*) (soff))->~G__TTGTableHeaderFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTableRange */
static int G__G__Gui3_387_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableRange* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTableRange[n];
     } else {
       p = new((void*) gvp) TTableRange[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTableRange;
     } else {
       p = new((void*) gvp) TTableRange;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TTableRange));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableRange*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTableRange*) G__getstructoffset())->operator==(*(TTableRange*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTableRange::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTableRange::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTableRange::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTableRange::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTableRange*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableRange*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableRange*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableRange*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTableRange::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTableRange::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTableRange::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_387_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTableRange::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_387_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTableRange* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTableRange(*(TTableRange*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TTableRange));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTableRange G__TTTableRange;
static int G__G__Gui3_387_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[] (TTableRange*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTableRange*) (soff+(sizeof(TTableRange)*i)))->~G__TTTableRange();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTableRange*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTableRange*) (soff))->~G__TTTableRange();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_387_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableRange* dest = (TTableRange*) G__getstructoffset();
   *dest = *(TTableRange*) libp->para[0].ref;
   const TTableRange& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSimpleTableInterface */
static int G__G__Gui3_388_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSimpleTableInterface* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSimpleTableInterface(
(Double_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) TGSimpleTableInterface(
(Double_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 TGSimpleTableInterface((Double_t**) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGSimpleTableInterface((Double_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 TGSimpleTableInterface((Double_t**) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGSimpleTableInterface((Double_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__Gui3LN_TGSimpleTableInterface));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSimpleTableInterface::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSimpleTableInterface::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSimpleTableInterface::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSimpleTableInterface::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSimpleTableInterface*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSimpleTableInterface::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSimpleTableInterface::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSimpleTableInterface::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_388_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSimpleTableInterface::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_388_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGSimpleTableInterface* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGSimpleTableInterface(*(TGSimpleTableInterface*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSimpleTableInterface G__TTGSimpleTableInterface;
static int G__G__Gui3_388_0_21(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[] (TGSimpleTableInterface*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSimpleTableInterface*) (soff+(sizeof(TGSimpleTableInterface)*i)))->~G__TTGSimpleTableInterface();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSimpleTableInterface*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSimpleTableInterface*) (soff))->~G__TTGSimpleTableInterface();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_388_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSimpleTableInterface* dest = (TGSimpleTableInterface*) G__getstructoffset();
   *dest = *(TGSimpleTableInterface*) libp->para[0].ref;
   const TGSimpleTableInterface& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSimpleTable */
static int G__G__Gui3_389_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSimpleTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGSimpleTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_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) TGSimpleTable(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t**) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSimpleTable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSimpleTable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSimpleTable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSimpleTable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSimpleTable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSimpleTable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSimpleTable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSimpleTable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_389_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSimpleTable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSimpleTable G__TTGSimpleTable;
static int G__G__Gui3_389_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGSimpleTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSimpleTable*) (soff+(sizeof(TGSimpleTable)*i)))->~G__TTGSimpleTable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSimpleTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSimpleTable*) (soff))->~G__TTGSimpleTable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGCommandPlugin */
static int G__G__Gui3_390_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCommandPlugin* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGCommandPlugin(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGCommandPlugin(
(TGWindow*) 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__Gui3LN_TGCommandPlugin));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCommandPlugin*) G__getstructoffset())->CheckRemote((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCommandPlugin*) G__getstructoffset())->HandleCommand();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGCommandPlugin::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCommandPlugin::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGCommandPlugin::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGCommandPlugin::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCommandPlugin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCommandPlugin::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCommandPlugin::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCommandPlugin::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_390_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCommandPlugin::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGCommandPlugin G__TTGCommandPlugin;
static int G__G__Gui3_390_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGCommandPlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGCommandPlugin*) (soff+(sizeof(TGCommandPlugin)*i)))->~G__TTGCommandPlugin();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGCommandPlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGCommandPlugin*) (soff))->~G__TTGCommandPlugin();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRootBrowser */
static int G__G__Gui3_391_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRootBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRootBrowser(
(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]), (Bool_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TRootBrowser(
(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]), (Bool_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRootBrowser(
(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) TRootBrowser(
(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 TRootBrowser(
(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) TRootBrowser(
(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;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRootBrowser(
(TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TRootBrowser(
(TBrowser*) G__int(libp->para[0]), (const char*) 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 TRootBrowser((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TRootBrowser((TBrowser*) 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 TRootBrowser((TBrowser*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TRootBrowser((TBrowser*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TRootBrowser[n];
       } else {
         p = new((void*) gvp) TRootBrowser[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TRootBrowser;
       } else {
         p = new((void*) gvp) TRootBrowser;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRootBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRootBrowser(
(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]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TRootBrowser(
(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]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRootBrowser(
(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) TRootBrowser(
(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 TRootBrowser(
(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) TRootBrowser(
(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__Gui3LN_TRootBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TRootBrowser*) G__getstructoffset())->InitPlugins((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TRootBrowser*) G__getstructoffset())->InitPlugins();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->CreateBrowser((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->CloneBrowser();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->CloseTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->DoTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetActFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetToolbarFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetStatusBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetTabLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetTabRight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetTabBottom());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRootBrowser*) G__getstructoffset())->GetTab((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRootBrowser*) G__getstructoffset())->SetTab((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRootBrowser*) G__getstructoffset())->SetTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TRootBrowser*) G__getstructoffset())->SetTab();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TRootBrowser*) G__getstructoffset())->SetTabTitle((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TRootBrowser*) G__getstructoffset())->SetTabTitle((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRootBrowser*) G__getstructoffset())->SetTabTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->HandleMenu((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->RecursiveReparent((TGPopupMenu*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->RemoveTab((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__Gui3_391_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->SetActBrowser((TBrowserImp*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->ShowMenu((TGCompositeFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRootBrowser*) G__getstructoffset())->StartEmbedding((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRootBrowser*) G__getstructoffset())->StartEmbedding((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TRootBrowser*) G__getstructoffset())->StartEmbedding();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TRootBrowser*) G__getstructoffset())->StopEmbedding((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TRootBrowser*) G__getstructoffset())->StopEmbedding();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->StopEmbedding((const char*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->SwitchMenus((TGCompositeFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->DoubleClicked((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->Checked((TObject*) 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__Gui3_391_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TRootBrowser*) 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:
      ((TRootBrowser*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRootBrowser*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 108, (long) ((TRootBrowser*) 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) ((TRootBrowser*) 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) ((TRootBrowser*) 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) ((TRootBrowser*) 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) ((TRootBrowser*) G__getstructoffset())->ExecPlugin((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 108, (long) ((TRootBrowser*) G__getstructoffset())->ExecPlugin());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->ShowCloseTab((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TRootBrowser*) G__getstructoffset())->IsCloseTabShown());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) TRootBrowser::NewBrowser((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) TRootBrowser::NewBrowser((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;
   case 3:
      G__letint(result7, 85, (long) TRootBrowser::NewBrowser((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TRootBrowser::NewBrowser((TBrowser*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TRootBrowser::NewBrowser((TBrowser*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TRootBrowser::NewBrowser());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) TRootBrowser::NewBrowser(
(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) TRootBrowser::NewBrowser((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__Gui3_391_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRootBrowser::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRootBrowser::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRootBrowser::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRootBrowser::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRootBrowser*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRootBrowser::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRootBrowser::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRootBrowser::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_391_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRootBrowser::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRootBrowser G__TTRootBrowser;
static int G__G__Gui3_391_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRootBrowser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRootBrowser*) (soff+(sizeof(TRootBrowser)*i)))->~G__TTRootBrowser();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRootBrowser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRootBrowser*) (soff))->~G__TTRootBrowser();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFileBrowser */
static int G__G__Gui3_394_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileBrowser(
(TGWindow*) G__int(libp->para[0]), (TBrowser*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGFileBrowser(
(TGWindow*) G__int(libp->para[0]), (TBrowser*) 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 TGFileBrowser(
(TGWindow*) G__int(libp->para[0]), (TBrowser*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFileBrowser(
(TGWindow*) G__int(libp->para[0]), (TBrowser*) 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 TGFileBrowser((TGWindow*) G__int(libp->para[0]), (TBrowser*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFileBrowser((TGWindow*) G__int(libp->para[0]), (TBrowser*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileBrowser((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFileBrowser((TGWindow*) 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__Gui3LN_TGFileBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGFileBrowser*) 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:
      ((TGFileBrowser*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGFileBrowser*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGFileBrowser*) G__getstructoffset())->GetNewBrowser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->SetNewBrowser((TRootBrowser*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGFileBrowser*) G__getstructoffset())->AddFSDirectory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGFileBrowser*) G__getstructoffset())->AddFSDirectory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGFileBrowser*) G__getstructoffset())->AddFSDirectory((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGFileBrowser*) G__getstructoffset())->AddKey((TGListTreeItem*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGFileBrowser*) G__getstructoffset())->AddKey((TGListTreeItem*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->AddRemoteFile((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->ApplyFilter((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->Chdir((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->Checked((TObject*) 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__Gui3_394_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->CheckRemote((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGFileBrowser*) G__getstructoffset())->CheckSorted((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGFileBrowser*) G__getstructoffset())->CheckSorted((TGListTreeItem*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->Clicked((TGListTreeItem*) 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__Gui3_394_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TGFileBrowser*) G__getstructoffset())->DirName((TGListTreeItem*) G__int(libp->para[0]));
         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__Gui3_394_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TGFileBrowser*) G__getstructoffset())->FullPathName((TGListTreeItem*) G__int(libp->para[0]));
         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__Gui3_394_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->DoubleClicked((TGListTreeItem*) 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__Gui3_394_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGFileBrowser*) G__getstructoffset())->XXExecuteDefaultAction((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGFileBrowser*) G__getstructoffset())->FormatFileInfo((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->GetFilePictures((const TGPicture**) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->GetObjPicture((const TGPicture**) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->GotoDir((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->PadModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->Selected((char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->ToggleSort();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->Update();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFileBrowser::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileBrowser::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFileBrowser::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFileBrowser::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileBrowser*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileBrowser::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileBrowser::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileBrowser::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_394_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileBrowser::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFileBrowser G__TTGFileBrowser;
static int G__G__Gui3_394_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGFileBrowser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFileBrowser*) (soff+(sizeof(TGFileBrowser)*i)))->~G__TTGFileBrowser();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFileBrowser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFileBrowser*) (soff))->~G__TTGFileBrowser();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBrowserPlugin */
static int G__G__Gui3_401_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowserPlugin* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserPlugin(
(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]));
     } else {
       p = new((void*) gvp) TBrowserPlugin(
(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]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserPlugin(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBrowserPlugin(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBrowserPlugin((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TBrowserPlugin((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 TBrowserPlugin((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TBrowserPlugin((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__Gui3LN_TBrowserPlugin));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserPlugin*) G__getstructoffset())->SetTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserPlugin*) G__getstructoffset())->SetSubTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserPlugin*) G__getstructoffset())->SetCommand((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBrowserPlugin::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBrowserPlugin::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBrowserPlugin::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBrowserPlugin::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBrowserPlugin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBrowserPlugin::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBrowserPlugin::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBrowserPlugin::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_401_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBrowserPlugin::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui3_401_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TBrowserPlugin* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TBrowserPlugin(*(TBrowserPlugin*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBrowserPlugin G__TTBrowserPlugin;
static int G__G__Gui3_401_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TBrowserPlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBrowserPlugin*) (soff+(sizeof(TBrowserPlugin)*i)))->~G__TTBrowserPlugin();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBrowserPlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBrowserPlugin*) (soff))->~G__TTBrowserPlugin();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui3_401_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBrowserPlugin* dest = (TBrowserPlugin*) G__getstructoffset();
   *dest = *(TBrowserPlugin*) libp->para[0].ref;
   const TBrowserPlugin& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRectMap */
static int G__G__Gui3_409_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRectMap* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRectMap(
(Int_t) G__int(libp->para[0]), (Int_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) TGRectMap(
(Int_t) G__int(libp->para[0]), (Int_t) 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__Gui3LN_TGRectMap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRectMap*) G__getstructoffset())->Contains((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRectMap::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRectMap::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRectMap::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRectMap::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRectMap*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRectMap::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRectMap::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRectMap::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_409_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRectMap::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRectMap G__TTGRectMap;
static int G__G__Gui3_409_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGRectMap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRectMap*) (soff+(sizeof(TGRectMap)*i)))->~G__TTGRectMap();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRectMap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRectMap*) (soff))->~G__TTGRectMap();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSplitTool */
static int G__G__Gui3_410_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSplitTool* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitTool((TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGSplitTool((TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitTool((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGSplitTool((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSplitTool[n];
       } else {
         p = new((void*) gvp) TGSplitTool[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSplitTool;
       } else {
         p = new((void*) gvp) TGSplitTool;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitTool*) G__getstructoffset())->AddRectangle((TGFrame*) 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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitTool*) G__getstructoffset())->Show((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__Gui3_410_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitTool*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitTool*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitTool*) G__getstructoffset())->SetPosition((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__Gui3_410_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSplitTool::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitTool::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSplitTool::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSplitTool::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitTool*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitTool::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitTool::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitTool::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_410_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitTool::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSplitTool G__TTGSplitTool;
static int G__G__Gui3_410_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[] (TGSplitTool*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSplitTool*) (soff+(sizeof(TGSplitTool)*i)))->~G__TTGSplitTool();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSplitTool*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSplitTool*) (soff))->~G__TTGSplitTool();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSplitFrame */
static int G__G__Gui3_411_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSplitFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitFrame(
(TGWindow*) 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) TGSplitFrame(
(TGWindow*) 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 TGSplitFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGSplitFrame(
(TGWindow*) 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 TGSplitFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGSplitFrame((TGWindow*) 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 TGSplitFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGSplitFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSplitFrame[n];
       } else {
         p = new((void*) gvp) TGSplitFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSplitFrame;
       } else {
         p = new((void*) gvp) TGSplitFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGSplitFrame*) G__getstructoffset())->HSplit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSplitFrame*) G__getstructoffset())->HSplit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGSplitFrame*) G__getstructoffset())->VSplit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSplitFrame*) G__getstructoffset())->VSplit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSplitFrame*) G__getstructoffset())->GetFirst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSplitFrame*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSplitFrame*) G__getstructoffset())->GetSecond());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSplitFrame*) G__getstructoffset())->GetSplitter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSplitFrame*) G__getstructoffset())->GetSplitTool());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGSplitFrame*) G__getstructoffset())->GetTopFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSplitFrame*) G__getstructoffset())->GetUndocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGSplitFrame*) G__getstructoffset())->GetHRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGSplitFrame*) G__getstructoffset())->GetWRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->MapToSPlitTool((TGSplitFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->OnSplitterClicked((Event_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->SetHRatio((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->SetWRatio((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGSplitFrame*) G__getstructoffset())->SplitHorizontal((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSplitFrame*) G__getstructoffset())->SplitHorizontal();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGSplitFrame*) G__getstructoffset())->SplitVertical((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSplitFrame*) G__getstructoffset())->SplitVertical();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->UnSplit((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->Close();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->CloseAndCollapse();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->ExtractFrame();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->SwallowBack();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->SwitchToMain();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->SplitHor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->SplitVer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->Docked((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->Undocked((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSplitFrame::SwitchFrames((TGFrame*) G__int(libp->para[0]), (TGCompositeFrame*) G__int(libp->para[1])
, (TGFrame*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSplitFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSplitFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSplitFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_411_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSplitFrame G__TTGSplitFrame;
static int G__G__Gui3_411_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[] (TGSplitFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSplitFrame*) (soff+(sizeof(TGSplitFrame)*i)))->~G__TTGSplitFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSplitFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSplitFrame*) (soff))->~G__TTGSplitFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGShapedFrame */
static int G__G__Gui3_412_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGShapedFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShapedFrame(
(const char*) G__int(libp->para[0]), (TGWindow*) 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) TGShapedFrame(
(const char*) G__int(libp->para[0]), (TGWindow*) 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 TGShapedFrame(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGShapedFrame(
(const char*) G__int(libp->para[0]), (TGWindow*) 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 TGShapedFrame(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGShapedFrame(
(const char*) G__int(libp->para[0]), (TGWindow*) 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 TGShapedFrame((const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGShapedFrame((const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShapedFrame((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGShapedFrame((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 TGShapedFrame[n];
       } else {
         p = new((void*) gvp) TGShapedFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGShapedFrame;
       } else {
         p = new((void*) gvp) TGShapedFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPicture* pobj;
         const TGPicture xobj = ((const TGShapedFrame*) G__getstructoffset())->GetPicture();
         pobj = new TGPicture(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__Gui3_412_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TImage* pobj;
         const TImage xobj = ((const TGShapedFrame*) G__getstructoffset())->GetImage();
         pobj = new TImage(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__Gui3_412_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGShapedFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShapedFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGShapedFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGShapedFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShapedFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShapedFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGShapedFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShapedFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_412_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGShapedFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGShapedFrame G__TTGShapedFrame;
static int G__G__Gui3_412_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGShapedFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGShapedFrame*) (soff+(sizeof(TGShapedFrame)*i)))->~G__TTGShapedFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGShapedFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGShapedFrame*) (soff))->~G__TTGShapedFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGEventHandler */
static int G__G__Gui3_413_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGEventHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGEventHandler(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGEventHandler(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TObject*) 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 TGEventHandler(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGEventHandler(
(const char*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TObject*) 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__Gui3LN_TGEventHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGEventHandler*) G__getstructoffset())->Activate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGEventHandler*) G__getstructoffset())->DeActivate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGEventHandler*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleEvent((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleConfigureNotify((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleButton((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleDoubleClick((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleCrossing((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleMotion((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleKey((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleFocusChange((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleSelection((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleSelectionRequest((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleSelectionClear((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->HandleColormapChange((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGEventHandler*) G__getstructoffset())->ProcessedEvent((Event_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGEventHandler*) G__getstructoffset())->SendMessage((TGWindow*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (Long_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGEventHandler*) G__getstructoffset())->ProcessMessage((Long_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGEventHandler*) G__getstructoffset())->Repaint();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGEventHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGEventHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGEventHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGEventHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGEventHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGEventHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGEventHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGEventHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui3_413_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGEventHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGEventHandler G__TTGEventHandler;
static int G__G__Gui3_413_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[] (TGEventHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGEventHandler*) (soff+(sizeof(TGEventHandler)*i)))->~G__TTGEventHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGEventHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGEventHandler*) (soff))->~G__TTGEventHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TRootGuiFactory */

/* TRootApplication */

/* TDNDData */

/* TGDockableFrame */

/* TGDNDManager */

/* TRootCanvas */

/* TRootBrowserLite */

/* TRootDialog */

/* TRootContextMenu */

/* TRootControlBar */

/* TRootHelpDialog */

/* TRootEmbeddedCanvas */

/* TGColorPalette */

/* TGColorPick */

/* TGColorDialog */

/* TGColorFrame */

/* TG16ColorSelector */

/* TGColorPopup */

/* TGColorSelect */

/* TGFontDialog */

/* TGFontDialog::FontProp_t */

/* TGDockButton */

/* TGDockHideButton */

/* TGUndockedFrame */

/* TGMdiMenuBar */

/* TGMdiContainer */

/* TGMdiDecorFrame */

/* TGMdiFrame */

/* TGMdiFrameList */

/* TGMdiMainFrame */

/* TGMdiGeometry */

/* TGMdiTitleIcon */

/* TGMdiButtons */

/* TGMdiTitleBar */

/* TGMdiWinResizer */

/* TGMdiVerticalWinResizer */

/* TGMdiHorizontalWinResizer */

/* TGMdiCornerWinResizer */

/* TVirtualDragManager */

/* TGuiBldAction */

/* TGuiBuilder */

/* TGRedirectOutputGuard */

/* TGPasswdDialog */

/* TGTextEditor */

/* TGSpeedo */

/* TGDragWindow */

/* TGTable */

/* TGTableCell */

/* TGTableHeader */

/* TGTableFrame */

/* TGTableHeaderFrame */

/* TTableRange */

/* TGSimpleTableInterface */

/* TGSimpleTable */

/* TGCommandPlugin */

/* TRootBrowser */

/* TGFileBrowser */

/* TBrowserPlugin */

/* TGRectMap */

/* TGSplitTool */

/* TGSplitFrame */

/* TGShapedFrame */

/* TGEventHandler */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Gui3 {
 public:
  G__Sizep2memfuncG__Gui3(): p(&G__Sizep2memfuncG__Gui3::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Gui3::*p)();
};

size_t G__get_sizep2memfuncG__Gui3()
{
  G__Sizep2memfuncG__Gui3 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__Gui3() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory))) {
     TRootGuiFactory *G__Lderived;
     G__Lderived=(TRootGuiFactory*)0x1000;
     {
       TGuiFactory *G__Lpbase=(TGuiFactory*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory),G__get_linked_tagnum(&G__G__Gui3LN_TGuiFactory),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory),G__get_linked_tagnum(&G__G__Gui3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication))) {
     TRootApplication *G__Lderived;
     G__Lderived=(TRootApplication*)0x1000;
     {
       TApplicationImp *G__Lpbase=(TApplicationImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication),G__get_linked_tagnum(&G__G__Gui3LN_TApplicationImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TDNDData))) {
     TDNDData *G__Lderived;
     G__Lderived=(TDNDData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TDNDData),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame))) {
     TGDockableFrame *G__Lderived;
     G__Lderived=(TGDockableFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager))) {
     TGDNDManager *G__Lderived;
     G__Lderived=(TGDNDManager*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas))) {
     TRootCanvas *G__Lderived;
     G__Lderived=(TRootCanvas*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCanvasImp *G__Lpbase=(TCanvasImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TCanvasImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite))) {
     TRootBrowserLite *G__Lderived;
     G__Lderived=(TRootBrowserLite*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBrowserImp *G__Lpbase=(TBrowserImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite),G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog))) {
     TRootDialog *G__Lderived;
     G__Lderived=(TRootDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu))) {
     TRootContextMenu *G__Lderived;
     G__Lderived=(TRootContextMenu*)0x1000;
     {
       TGPopupMenu *G__Lpbase=(TGPopupMenu*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TContextMenuImp *G__Lpbase=(TContextMenuImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),G__get_linked_tagnum(&G__G__Gui3LN_TContextMenuImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar))) {
     TRootControlBar *G__Lderived;
     G__Lderived=(TRootControlBar*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TControlBarImp *G__Lpbase=(TControlBarImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar),G__get_linked_tagnum(&G__G__Gui3LN_TControlBarImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog))) {
     TRootHelpDialog *G__Lderived;
     G__Lderived=(TRootHelpDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas))) {
     TRootEmbeddedCanvas *G__Lderived;
     G__Lderived=(TRootEmbeddedCanvas*)0x1000;
     {
       TGCanvas *G__Lpbase=(TGCanvas*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette))) {
     TGColorPalette *G__Lderived;
     G__Lderived=(TGColorPalette*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick))) {
     TGColorPick *G__Lderived;
     G__Lderived=(TGColorPick*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog))) {
     TGColorDialog *G__Lderived;
     G__Lderived=(TGColorDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame))) {
     TGColorFrame *G__Lderived;
     G__Lderived=(TGColorFrame*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector))) {
     TG16ColorSelector *G__Lderived;
     G__Lderived=(TG16ColorSelector*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup))) {
     TGColorPopup *G__Lderived;
     G__Lderived=(TGColorPopup*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect))) {
     TGColorSelect *G__Lderived;
     G__Lderived=(TGColorSelect*)0x1000;
     {
       TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog))) {
     TGFontDialog *G__Lderived;
     G__Lderived=(TGFontDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton))) {
     TGDockButton *G__Lderived;
     G__Lderived=(TGDockButton*)0x1000;
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton))) {
     TGDockHideButton *G__Lderived;
     G__Lderived=(TGDockHideButton*)0x1000;
     {
       TGDockButton *G__Lpbase=(TGDockButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame))) {
     TGUndockedFrame *G__Lderived;
     G__Lderived=(TGUndockedFrame*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar))) {
     TGMdiMenuBar *G__Lderived;
     G__Lderived=(TGMdiMenuBar*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer))) {
     TGMdiContainer *G__Lderived;
     G__Lderived=(TGMdiContainer*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame))) {
     TGMdiDecorFrame *G__Lderived;
     G__Lderived=(TGMdiDecorFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame))) {
     TGMdiFrame *G__Lderived;
     G__Lderived=(TGMdiFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame))) {
     TGMdiMainFrame *G__Lderived;
     G__Lderived=(TGMdiMainFrame*)0x1000;
     {
       TGCanvas *G__Lpbase=(TGCanvas*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon))) {
     TGMdiTitleIcon *G__Lderived;
     G__Lderived=(TGMdiTitleIcon*)0x1000;
     {
       TGIcon *G__Lpbase=(TGIcon*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGIcon),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons))) {
     TGMdiButtons *G__Lderived;
     G__Lderived=(TGMdiButtons*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGIcon))) {
     TGIcon *G__Lderived;
     G__Lderived=(TGIcon*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGIcon),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGIcon),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGIcon),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar))) {
     TGMdiTitleBar *G__Lderived;
     G__Lderived=(TGMdiTitleBar*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer))) {
     TGMdiWinResizer *G__Lderived;
     G__Lderived=(TGMdiWinResizer*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer))) {
     TGMdiVerticalWinResizer *G__Lderived;
     G__Lderived=(TGMdiVerticalWinResizer*)0x1000;
     {
       TGMdiWinResizer *G__Lpbase=(TGMdiWinResizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer))) {
     TGMdiHorizontalWinResizer *G__Lderived;
     G__Lderived=(TGMdiHorizontalWinResizer*)0x1000;
     {
       TGMdiWinResizer *G__Lpbase=(TGMdiWinResizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer))) {
     TGMdiCornerWinResizer *G__Lderived;
     G__Lderived=(TGMdiCornerWinResizer*)0x1000;
     {
       TGMdiWinResizer *G__Lpbase=(TGMdiWinResizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction))) {
     TGuiBldAction *G__Lderived;
     G__Lderived=(TGuiBldAction*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction),G__get_linked_tagnum(&G__G__Gui3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor))) {
     TGTextEditor *G__Lderived;
     G__Lderived=(TGTextEditor*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo))) {
     TGSpeedo *G__Lderived;
     G__Lderived=(TGSpeedo*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow))) {
     TGDragWindow *G__Lderived;
     G__Lderived=(TGDragWindow*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGTable))) {
     TGTable *G__Lderived;
     G__Lderived=(TGTable*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell))) {
     TGTableCell *G__Lderived;
     G__Lderived=(TGTableCell*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader))) {
     TGTableHeader *G__Lderived;
     G__Lderived=(TGTableHeader*)0x1000;
     {
       TGTableCell *G__Lpbase=(TGTableCell*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGTableFrame))) {
     TGTableFrame *G__Lderived;
     G__Lderived=(TGTableFrame*)0x1000;
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame))) {
     TGTableHeaderFrame *G__Lderived;
     G__Lderived=(TGTableHeaderFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface))) {
     TGSimpleTableInterface *G__Lderived;
     G__Lderived=(TGSimpleTableInterface*)0x1000;
     {
       TVirtualTableInterface *G__Lpbase=(TVirtualTableInterface*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface),G__get_linked_tagnum(&G__G__Gui3LN_TVirtualTableInterface),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable))) {
     TGSimpleTable *G__Lderived;
     G__Lderived=(TGSimpleTable*)0x1000;
     {
       TGTable *G__Lpbase=(TGTable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TGTable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable),G__get_linked_tagnum(&G__G__Gui3LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin))) {
     TGCommandPlugin *G__Lderived;
     G__Lderived=(TGCommandPlugin*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser))) {
     TRootBrowser *G__Lderived;
     G__Lderived=(TRootBrowser*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBrowserImp *G__Lpbase=(TBrowserImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser))) {
     TGFileBrowser *G__Lderived;
     G__Lderived=(TGFileBrowser*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBrowserImp *G__Lpbase=(TBrowserImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser),G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin))) {
     TBrowserPlugin *G__Lderived;
     G__Lderived=(TBrowserPlugin*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap))) {
     TGRectMap *G__Lderived;
     G__Lderived=(TGRectMap*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool))) {
     TGSplitTool *G__Lderived;
     G__Lderived=(TGSplitTool*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame))) {
     TGSplitFrame *G__Lderived;
     G__Lderived=(TGSplitFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame))) {
     TGShapedFrame *G__Lderived;
     G__Lderived=(TGShapedFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler))) {
     TGEventHandler *G__Lderived;
     G__Lderived=(TGEventHandler*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler),G__get_linked_tagnum(&G__G__Gui3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler),G__get_linked_tagnum(&G__G__Gui3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler),G__get_linked_tagnum(&G__G__Gui3LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Gui3() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Gui3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Gui3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,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("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("Pixel_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixel value",0);
   G__search_typename2("Time_t",107,-1,0,-1);
   G__setnewtype(-1,"Event time",0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3LN_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__Gui3LN_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__Gui3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__Gui3LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGListTreeItem*>",117,G__get_linked_tagnum(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("sLTI_t",117,G__get_linked_tagnum(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgR),0,G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("sLTI_i",117,G__get_linked_tagnum(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("sLTI_ri",117,G__get_linked_tagnum(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLreverse_iterator),0,G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TRootGuiFactory */
static void G__setup_memvarTRootGuiFactory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory));
   { TRootGuiFactory *p; p=(TRootGuiFactory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootApplication */
static void G__setup_memvarTRootApplication(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication));
   { TRootApplication *p; p=(TRootApplication*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGClient),-1,-1,4,"fClient=",0,"pointer to the client environment");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fDisplay=",0,"display server to connect to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDNDData */
static void G__setup_memvarTDNDData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TDNDData));
   { TDNDData *p; p=(TDNDData*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fDataType)-(long)(p)),107,0,0,-1,G__defined_typename("Atom_t"),-1,1,"fDataType=",0,"Data type description");
   G__memvar_setup((void*)((long)(&p->fAction)-(long)(p)),107,0,0,-1,G__defined_typename("Atom_t"),-1,1,"fAction=",0,"Action description");
   G__memvar_setup((void*)((long)(&p->fData)-(long)(p)),89,0,0,-1,-1,-1,1,"fData=",0,"Actual data");
   G__memvar_setup((void*)((long)(&p->fDataLength)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fDataLength=",0,"Length of data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDockableFrame */
static void G__setup_memvarTGDockableFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame));
   { TGDockableFrame *p; p=(TGDockableFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHidden=",0,"if frame is hidden");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnableHide=",0,"if frame can be hidden");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnableUndock=",0,"if frame can be undocked");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDeleted=",0,"kTRUE if it is being deleted");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFixedSize=",0,"kTRUE if fixed size when undocked");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fDockName=",0,"name of frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fContainer=",0,"container containing dockable frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fButtons=",0,"container containing dock and hide buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton),-1,-1,2,"fDockButton=",0,"dock button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton),-1,-1,2,"fHideButton=",0,"hide button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame),-1,-1,2,"fFrame=",0,"undocked frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fCl=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fHints=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLc=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDNDManager */
static void G__setup_memvarTGDNDManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager));
   { TGDNDManager *p; p=(TGDNDManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fMain=",0,"pointer on TGMainFrame");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fVersion=",0,"not really an Atom, but a long");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fTypelist=",0,(char*)NULL);
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fDraggerTypes=",0,"lists of DND types");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fDropType=",0,"drop type");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fAcceptedAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fLocalAction=",0,"accepted and local actions");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDragging=",0,"kTRUE while dragging");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDropAccepted=",0,"kTRUE if drop accepted");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStatusPending=",0,"kTRUE if status is pending");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseVersion=",0,"kTRUE if DND version is used");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fProxyOurs=",0,"kTRUE if root proxy is ours");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-1,2,"fSource=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-1,2,"fTarget=",0,"source and target windows");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTargetIsDNDAware=",0,"kTRUE if target is DND aware");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fGrabEventMask=",0,"pointer grab event mask");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fLocalSource=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fLocalTarget=",0,"local source and target");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TTimer),-1,-1,2,"fDropTimeout=",0,"drop timeout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow),-1,-1,2,"fDragWin=",0,"drag window");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPic=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fMask=",0,"pixmap used for the drag window");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHotx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHoty=",0,"hot point coordinates");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,2,"fDNDNoDropCursor=",0,"no drop cursor type");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDAware=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDProxy=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDEnter=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDLeave=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDStatus=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDDrop=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDFinished=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDVersion=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionCopy=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionMove=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionLink=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionAsk=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionPrivate=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDTypeList=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionList=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgDNDActionDescrip=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgXCDNDData=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgInit=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-2,2,"fgXAWMState=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootCanvas */
static void G__setup_memvarTRootCanvas(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas));
   { TRootCanvas *p; p=(TRootCanvas*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),-1,-1,4,"fCanvasWindow=",0,"canvas widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootContainer),-1,-1,4,"fCanvasContainer=",0,"container in canvas widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar),-1,-1,4,"fMenuBar=",0,"menubar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fFileMenu=",0,"file menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fFileSaveMenu=",0,"save cascade submenu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fEditMenu=",0,"edit menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fEditClearMenu=",0,"clear cascade submenu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fViewMenu=",0,"view menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fViewWithMenu=",0,"view with... cascade submenu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fOptionMenu=",0,"option menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fToolsMenu=",0,"tools menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,4,"fHelpMenu=",0,"help menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMenuBarLayout=",0,"menubar layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMenuBarItemLayout=",0,"layout hints for menu in menubar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMenuBarHelpLayout=",0,"layout hint for help menu in menubar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fCanvasLayout=",0,"layout for canvas widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar),-1,-1,4,"fStatusBar=",0,"statusbar widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fStatusBarLayout=",0,"layout hints for statusbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,4,"fEditorFrame=",0,"side frame for current pad editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fEditorLayout=",0,"layout for editor frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,4,"fMainFrame=",0,"main frame containing canvas and side frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fToolBarLayout=",0,"layout for toolbar widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGToolBar),-1,-1,4,"fToolBar=",0,"icon button toolbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontal3DLine),-1,-1,4,"fToolBarSep=",0,"toolbar separator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMainFrameLayout=",0,"layout for main frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVertical3DLine),-1,-1,4,"fVertical1=",0,"toolbar vertical separator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVertical3DLine),-1,-1,4,"fVertical2=",0,"toolbar vertical separator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontal3DLine),-1,-1,4,"fHorizontal1=",0,"toolbar sepatator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fVertical1Layout=",0,"layout hints for separator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fVertical2Layout=",0,"layout hints for separator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fHorizontal1Layout=",0,"layout hints for separator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),-1,-1,4,"fToolDock=",0,"dockable frame holding the toolbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fDockLayout=",0,"layout hints for dockable frame widget");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,4,"fIconPic=",0,"icon picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGToolTip),-1,-1,4,"fToolTip=",0,"tooltip for object info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TVirtualPadEditor),-1,-1,4,"fEditor=",0,"pointer to currently loaded pad editor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanvasID=",0,"index in fWindows array of TGX11");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAutoFit=",0,"when true canvas container keeps same size as canvas");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fButton=",0,"currently pressed button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootBrowserLite */
static void G__setup_memvarTRootBrowserLite(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite));
   { TRootBrowserLite *p; p=(TRootBrowserLite*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar),-1,-1,4,"fMenuBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGToolBar),-1,-1,4,"fToolBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontal3DLine),-1,-1,4,"fToolBarSep=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVerticalFrame),-1,-1,4,"fV1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVerticalFrame),-1,-1,4,"fV2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,4,"fLbl1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,4,"fLbl2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,4,"fHf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,4,"fTreeHdr=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,4,"fListHdr=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMenuBarLayout=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMenuBarItemLayout=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fMenuBarHelpLayout=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fComboLayout=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fBarLayout=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGComboBox),-1,-1,4,"fDrawOption=",0,"drawing option entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fExpandLayout=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBrowseTextFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,4,"fTextFileName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,4,"fWidgets=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,4,"fHistory=",0,"history of browsing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TObject),-1,-1,4,"fHistoryCursor=",0,"current hsitory position");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,4,"fIconPic=",0,"icon picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fFileMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fViewMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fOptionMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fHelpMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fSortMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListView),-1,-1,2,"fListView=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootIconBox),-1,-1,2,"fIconBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),-1,-1,2,"fTreeView=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListTree),-1,-1,2,"fLt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGButton),-1,-1,2,"fToolBarButton[7]=",0,"same size as gToolBarData[]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFSComboBox),-1,-1,2,"fFSComboBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar),-1,-1,2,"fStatusBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListTreeItem),-1,-1,2,"fListLevel=",0,"current TGListTree level");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTreeLock=",0,"true when we want to lock TGListTree");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fViewMode=",0,"current IconBox view mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSortMode=",0,"current IconBox sort mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEdit),-1,-1,2,"fTextEdit=",0,"contents of browsed text file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootDialog */
static void G__setup_memvarTRootDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog));
   { TRootDialog *p; p=(TRootDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu),-1,-1,4,"fMenu=",0,"associated context menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fL1=",0,"label layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fL2=",0,"text entry layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,4,"fWidgets=",0,"label and text field widgets created in dialog");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fOk=",0,"if true show OK button");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCancel=",0,"if true show Cancel button");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fApply=",0,"if true show Apply button");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHelp=",0,"if true show Online Help button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootContextMenu */
static void G__setup_memvarTRootContextMenu(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu));
   { TRootContextMenu *p; p=(TRootContextMenu*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog),-1,-1,4,"fDialog=",0,"dialog prompting for command line arguments");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,4,"fTrash=",0,"list of objects to be deleted before refilling menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootControlBar */
static void G__setup_memvarTRootControlBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar));
   { TRootControlBar *p; p=(TRootControlBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,4,"fWidgets=",0,"list of TGTextButton or TGPictureButtons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fL1=",0,"button layout hints");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBwidth=",0,"button width in pixels");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootHelpDialog */
static void G__setup_memvarTRootHelpDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog));
   { TRootHelpDialog *p; p=(TRootHelpDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextView),-1,-1,4,"fView=",0,"text view");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,4,"fOK=",0,"OK button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fL1=",0,"layout of TGTextView");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,4,"fL2=",0,"layout of OK button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootEmbeddedCanvas */
static void G__setup_memvarTRootEmbeddedCanvas(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas));
   { TRootEmbeddedCanvas *p; p=(TRootEmbeddedCanvas*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCWinId=",0,"window id used by embedded TCanvas");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedContainer),-1,-1,2,"fCanvasContainer=",0,"container in canvas widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TCanvas),-1,-1,2,"fCanvas=",0,"pointer to TCanvas");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoFit=",0,"canvas container keeps same size as canvas");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fButton=",0,"currently pressed button");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fDNDTypeList=",0,"handles DND types");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColorPalette */
static void G__setup_memvarTGColorPalette(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette));
   { TGColorPalette *p; p=(TGColorPalette*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCx=",0,"x coordinate of currently selected color cell");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCy=",0,"y coordinate of currently selected color cell");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCw=",0,"color cell width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCh=",0,"color cell height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRows=",0,"number of color cell rows");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCols=",0,"number of color cell columns");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fPixels=",0,"pixel value of colors");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,2,"fDrawGC=",0,"graphics context used for drawing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColorPick */
static void G__setup_memvarTGColorPick(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick));
   { TGColorPick *p; p=(TGColorPick*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColormap[64][3]=",0,"colormap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fPixel[64]=",0,"pixel values");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fHSimage=",0,"hue / saturation colormap pixmap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fLimage=",0,"color lightness slider pixmap");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNColors=",0,"number of color samples");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fClick=",0,"mouse click location (kCLICK_NONE, kCLICK_HS, kCLICK_L)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCx=",0,"x position in hs colormap");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCy=",0,"y position in hs colormap");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCz=",0,"position in lightness slider ");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fCurrentColor=",0,"currently selected color value");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_Rectangle_t),-1,-1,2,"fColormapRect=",0,"hue / saturation colormap rectangle");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_Rectangle_t),-1,-1,2,"fSliderRect=",0,"color lightness slider rectangle");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,2,"fCursorGC=",0,"color lightness slider cursor GC");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColorDialog */
static void G__setup_memvarTGColorDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog));
   { TGColorDialog *p; p=(TGColorDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fCurrentColor=",0,"currently selected color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fInitColor=",0,"initially set color");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRetc=",0,"return code (kMBOk, kMBCancel)");
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fRetColor=",0,"return color");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),-1,-1,2,"fPalette=",0,"color palette");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette),-1,-1,2,"fCpalette=",0,"color palette");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick),-1,-1,2,"fColors=",0,"color pick widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fSample=",0,"color sample frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fSampleOld=",0,"color sample frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fRte=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fGte=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fBte=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fHte=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fLte=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fSte=",0,"RGB/HLS text entries");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fRtb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fGtb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fBtb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fHtb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fLtb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fStb=",0,"RGB/HLS associated buffers");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fWaitFor=",0,"call WaitFor method in constructor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTab),-1,-1,2,"fTab=",0,"tab widget holding the color selectors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas),-1,-1,2,"fEcanvas=",0,"embedded canvas holding the color wheel");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TColorWheel),-1,-1,2,"fColorWheel=",0,"color wheel");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fColorInfo=",0,"color info");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,2,"fPreview=",0,"preview button;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColorFrame */
static void G__setup_memvarTGColorFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame));
   { TGColorFrame *p; p=(TGColorFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window handling container messages");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fPixel=",0,"color value of this cell");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"kTRUE if this color cell is active");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fGrayGC=",0,"Shadow GC");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fColor=",0,"returned color value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TG16ColorSelector */
static void G__setup_memvarTG16ColorSelector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector));
   { TG16ColorSelector *p; p=(TG16ColorSelector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActive=",0,"index of active color cell");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window handling container messages");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame),-1,-1,2,"fCe[16]=",0,"matrix of color cells");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColorPopup */
static void G__setup_memvarTGColorPopup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup));
   { TGColorPopup *p; p=(TGColorPopup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActive=",0,"active color index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLaunchDialog=",0,"flag used for launching color dialog");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window handling container messages");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fCurrentColor=",0,"currently selected color value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColorSelect */
static void G__setup_memvarTGColorSelect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect));
   { TGColorSelect *p; p=(TGColorSelect*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fColor=",0,"color value of the button");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,2,"fDrawGC=",0,"drawing GC");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup),-1,-1,2,"fColorPopup=",0,"color popup associated");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPosition),-1,-1,2,"fPressPos=",0,"psotion of frame on button press event");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFontDialog */
static void G__setup_memvarTGFontDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog));
   { TGFontDialog *p; p=(TGFontDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListBox),-1,-1,2,"fFontNames=",0,"list of font names");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListBox),-1,-1,2,"fFontSizes=",0,"list of font sizes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListBox),-1,-1,2,"fFontStyles=",0,"list of font styles");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGComboBox),-1,-1,2,"fTextAligns=",0,"font alignment selection");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fSample=",0,"sample of selected font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"color selection dialog");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fName=",0,"font name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fLName=",0,"logical font name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t),-1,-1,2,"fFontProp=",0,"font info structure");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fItalic=",0,"italic flag");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBold=",0,"bold flag");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"font size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTextAlign=",0,"text aligment");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fTextColor=",0,"text color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fInitColor=",0,"initial value of text color");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInitAlign=",0,"initialvalue of  text align");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFont),-1,-1,2,"fInitFont=",0,"initial font");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fSampleText=",0,"string used for sample");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,2,"fSampleTextGC=",0,"GC used for sample text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFont),-1,-1,2,"fLabelFont=",0,"TGFont used for sample text");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHitOK=",0,"flag = kTRUE if user press the Ok button");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumberOfFonts=",0,"total numbder of fonts");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fWaitFor=",0,"if kTRUE WaitForUnmap is called in constructor.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFontDialog::FontProp_t */
static void G__setup_memvarTGFontDialogcLcLFontProp_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t));
   { TGFontDialog::FontProp_t *p; p=(TGFontDialog::FontProp_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,1,"fName=",0,"font name");
   G__memvar_setup((void*)((long)(&p->fSize)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSize=",0,"font size");
   G__memvar_setup((void*)((long)(&p->fAlign)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fAlign=",0,"text alignment");
   G__memvar_setup((void*)((long)(&p->fColor)-(long)(p)),107,0,0,-1,G__defined_typename("Pixel_t"),-1,1,"fColor=",0,"text color");
   G__memvar_setup((void*)((long)(&p->fBold)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fBold=",0,"bold flag");
   G__memvar_setup((void*)((long)(&p->fItalic)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fItalic=",0,"italic flag");
   }
   G__tag_memvar_reset();
}


   /* TGDockButton */
static void G__setup_memvarTGDockButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton));
   { TGDockButton *p; p=(TGDockButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMouseOn=",0,"true when mouse on button");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fNormBg=",0,"normal background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fHiBg=",0,"highlighted background color");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDockHideButton */
static void G__setup_memvarTGDockHideButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton));
   { TGDockHideButton *p; p=(TGDockHideButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fAspectRatio=",0,"triangle orientation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGUndockedFrame */
static void G__setup_memvarTGUndockedFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame));
   { TGUndockedFrame *p; p=(TGUndockedFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame),-1,-1,2,"fDockable=",0,"orignal dockable frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiMenuBar */
static void G__setup_memvarTGMdiMenuBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar));
   { TGMdiMenuBar *p; p=(TGMdiMenuBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fLeft=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fRight=",0,"left and right parts of MDI menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar),-1,-1,2,"fBar=",0,"standard menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLeftHint=",0,"left layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fRightHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fBarHint=",0,"right layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiContainer */
static void G__setup_memvarTGMdiContainer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer));
   { TGMdiContainer *p; p=(TGMdiContainer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),-1,-1,2,"fMain=",0,"pointer to MDI main frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiDecorFrame */
static void G__setup_memvarTGMdiDecorFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame));
   { TGMdiDecorFrame *p; p=(TGMdiDecorFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPreResizeX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPreResizeY=",0,"position before resizing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPreResizeWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPreResizeHeight=",0,"dimension before resizing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinimizedX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinimizedY=",0,"minimized position");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMinimized=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMaximized=",0,"minimized and maximized flags");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMinimizedUserPlacement=",0,"user placement flag");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsCurrent=",0,"current mdi window flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame),-1,-1,2,"fFrame=",0,"parent (owner) MDI frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),-1,-1,2,"fMdiMainFrame=",0,"MDI main frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),-1,-1,2,"fUpperHR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer),-1,-1,2,"fLowerHR=",0,"upper and lower vertical resizers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),-1,-1,2,"fUpperLeftCR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),-1,-1,2,"fLowerLeftCR=",0,"upper left and lower left resizers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),-1,-1,2,"fUpperRightCR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer),-1,-1,2,"fLowerRightCR=",0,"upper right and lower right resizers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),-1,-1,2,"fLeftVR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer),-1,-1,2,"fRightVR=",0,"left and right horizontal resizers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fExpandHint=",0,"layout hints");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fButtonMask=",0,"mask used to display/hide buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar),-1,-1,2,"fTitlebar=",0,"MDI window title bar");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFramecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kMdiBorderWidth=%lldLL",(long long)TGMdiDecorFrame::kMdiBorderWidth).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiFrame */
static void G__setup_memvarTGMdiFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame));
   { TGMdiFrame *p; p=(TGMdiFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFramecLcLdA),-1,-2,2,"kDontCallClose=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame),-1,-1,2,"fMain=",0,"pointer to the MDI main frame");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fMdiHints=",0,"MDI hints, also used to identify titlebar buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiFrameList */
static void G__setup_memvarTGMdiFrameList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList));
   { TGMdiFrameList *p; p=(TGMdiFrameList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFrameId=",0,"TGMdiFrameList Id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame),-1,-1,2,"fDecor=",0,"MDI decor frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList),-1,-1,2,"fPrev=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList),-1,-1,2,"fNext=",0,"pointers on previous and next TGMdiFrameList");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList),-1,-1,2,"fCyclePrev=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList),-1,-1,2,"fCycleNext=",0,"pointers on previous and next TGMdiFrameList");
   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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiMainFrame */
static void G__setup_memvarTGMdiMainFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame));
   { TGMdiMainFrame *p; p=(TGMdiMainFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFramecLcLdA),-1,-2,2,"kMinimizedWidth=5LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrentX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrentY=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fResizeMode=",0,"current MDI child XY position and resize mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fArrangementMode=",0,"MDI childs arrangement mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFont),-1,-1,2,"fFontCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFont),-1,-1,2,"fFontNotCurrent=",0,"fonts for active and inactive MDI childs");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBackCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fForeCurrent=",0,"back and fore colors for active MDI childs");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBackNotCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fForeNotCurrent=",0,"back and fore colors for inactive MDI childs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,2,"fBoxGC=",0,"GC used to draw resizing box (rectangle)");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fNumberOfFrames=",0,"number of MDI child windows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar),-1,-1,2,"fMenuBar=",0,"menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fContainer=",0,"MDI container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fWinListMenu=",0,"popup menu with list of MDI child windows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList),-1,-1,2,"fChildren=",0,"list of MDI child windows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList),-1,-1,2,"fCurrent=",0,"current list of MDI child windows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiGeometry */
static void G__setup_memvarTGMdiGeometry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry));
   { TGMdiGeometry *p; p=(TGMdiGeometry*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fValueMask)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fValueMask=",0,"MDI hints mask");
   G__memvar_setup((void*)((long)(&p->fClient)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGRectangle),-1,-1,1,"fClient=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fDecoration)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGRectangle),-1,-1,1,"fDecoration=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fIcon)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGRectangle),-1,-1,1,"fIcon=",0,"client, decoration and icon rectangles");
   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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiTitleIcon */
static void G__setup_memvarTGMdiTitleIcon(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon));
   { TGMdiTitleIcon *p; p=(TGMdiTitleIcon*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window handling container messages");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fPopup=",0,"Popup menu associated to the title icon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiButtons */
static void G__setup_memvarTGMdiButtons(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons));
   { TGMdiButtons *p; p=(TGMdiButtons*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPictureButton),-1,-1,2,"fButton[5]=",0,"MDI picture buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fDefaultHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fCloseHint=",0,"Layout hints");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window handling container messages");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiTitleBar */
static void G__setup_memvarTGMdiTitleBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar));
   { TGMdiTitleBar *p; p=(TGMdiTitleBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMdiWin=",0,"owner MDI window");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons),-1,-1,2,"fButtons=",0,"MDI buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon),-1,-1,2,"fWinIcon=",0,"title icon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fWinName=",0,"window name label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fLFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fMFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fRFrame=",0,"the three parts of the title bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLeftHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fMiddleHint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fRightHint=",0,"layout hints");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX0=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY0=",0,"initial position of the mouse click");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLeftButPressed=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRightButPressed=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMidButPressed=",0,"mouse button pressed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiWinResizer */
static void G__setup_memvarTGMdiWinResizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer));
   { TGMdiWinResizer *p; p=(TGMdiWinResizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,2,"fMdiWin=",0,"owner MDI Window");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWinX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWinY=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWinW=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWinH=",0,"MDI win position and dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOldX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOldY=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOldW=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOldH=",0,"old MDI win position and dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNewX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNewY=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNewW=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNewH=",0,"new MDI win position and dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinW=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinH=",0,"Min width and height of the MDI Win");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMdiOptions=",0,"MDI options");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPos=",0,"position of the resizer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX0=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY0=",0,"initial position of the mouse click");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLeftButPressed=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRightButPressed=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMidButPressed=",0,"mouse buttons flags");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,2,"fBoxGC=",0,"GC used for resizing rectangle");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLineW=",0,"line width of resizing rectangle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiVerticalWinResizer */
static void G__setup_memvarTGMdiVerticalWinResizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer));
   { TGMdiVerticalWinResizer *p; p=(TGMdiVerticalWinResizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiHorizontalWinResizer */
static void G__setup_memvarTGMdiHorizontalWinResizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer));
   { TGMdiHorizontalWinResizer *p; p=(TGMdiHorizontalWinResizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMdiCornerWinResizer */
static void G__setup_memvarTGMdiCornerWinResizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer));
   { TGMdiCornerWinResizer *p; p=(TGMdiCornerWinResizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualDragManager */
static void G__setup_memvarTVirtualDragManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager));
   { TVirtualDragManager *p; p=(TVirtualDragManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMoveWaiting=",0,"kTRUE if source is clicked but not moved");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDragging=",0,"in dragging mode?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDropping=",0,"drop is in progress");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPasting=",0,"paste action is in progress");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,2,"fDragType=",0,"dragging type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fSource=",0,"frame being dragged");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fFrameUnder=",0,"frame under drag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fTarget=",0,"drop target");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fPasteFrame=",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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGuiBldAction */
static void G__setup_memvarTGuiBldAction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction));
   { TGuiBldAction *p; p=(TGuiBldAction*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fType=",0,"type of action");
   G__memvar_setup((void*)((long)(&p->fAct)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,1,"fAct=",0,"action, after action execution new frame is created");
   G__memvar_setup((void*)((long)(&p->fPic)-(long)(p)),67,0,1,-1,-1,-1,1,"fPic=",0,"picture name");
   G__memvar_setup((void*)((long)(&p->fPicture)-(long)(p)),85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,1,"fPicture=",0,"picture");
   G__memvar_setup((void*)((long)(&p->fHints)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,1,"fHints=",0,"layout hints for frame created by action");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGuiBuilder */
static void G__setup_memvarTGuiBuilder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder));
   { TGuiBuilder *p; p=(TGuiBuilder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction),-1,-1,2,"fAction=",0,"current action");
   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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRedirectOutputGuard */
static void G__setup_memvarTGRedirectOutputGuard(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGRedirectOutputGuard));
   { TGRedirectOutputGuard *p; p=(TGRedirectOutputGuard*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,4,"fLogFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTmpFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextView),-1,-1,4,"fTextView=",0,(char*)NULL);
   G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFileRead=",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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPasswdDialog */
static void G__setup_memvarTGPasswdDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog));
   { TGPasswdDialog *p; p=(TGPasswdDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fPwdBuf=",0,"buffer where to store the passwd");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPwdLenMax=",0,"passwd buffer length");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),-1,-1,4,"fDialog=",0,"main frame of this widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,4,"fOk=",0,"Ok button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,4,"fPasswd=",0,"Password TextEntry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,4,"fPasswdText=",0,"Passwd Buffer");
   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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextEditor */
static void G__setup_memvarTGTextEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor));
   { TGTextEditor *p; p=(TGTextEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TTimer),-1,-1,2,"fTimer=",0,"for statusbar and toolbar update");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar),-1,-1,2,"fStatusBar=",0,"for file name, line and col number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGToolBar),-1,-1,2,"fToolBar=",0,"toolbar with common tool buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEdit),-1,-1,2,"fTextEdit=",0,"text edit widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fLabel=",0,"\"command\" label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGComboBox),-1,-1,2,"fComboCmd=",0,"commands combobox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fCommand=",0,"command text entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fCommandBuf=",0,"command text buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fMenuBarLayout=",0,"used for the menubar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fMenuBarItemLayout=",0,"used for for menubar items");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar),-1,-1,2,"fMenuBar=",0,"editor's menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuFile=",0,"\"File\" menu entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuEdit=",0,"\"Edit\" menu entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuSearch=",0,"\"Search\" menu entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuTools=",0,"\"Tools\" menu entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuHelp=",0,"\"Help\" menu entry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fExiting=",0,"true if editor is closing");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTextChanged=",0,"true if text has changed");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fFilename=",0,"name of the opened file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TMacro),-1,-1,2,"fMacro=",0,"pointer on the opened macro");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSpeedo */
static void G__setup_memvarTGSpeedo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo));
   { TGSpeedo *p; p=(TGSpeedo*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedocLcLEGlowColor),-1,-2,1,G__FastAllocString(2048).Format("kNoglow=%lldLL",(long long)TGSpeedo::kNoglow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedocLcLEGlowColor),-1,-2,1,G__FastAllocString(2048).Format("kGreen=%lldLL",(long long)TGSpeedo::kGreen).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedocLcLEGlowColor),-1,-2,1,G__FastAllocString(2048).Format("kOrange=%lldLL",(long long)TGSpeedo::kOrange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedocLcLEGlowColor),-1,-2,1,G__FastAllocString(2048).Format("kRed=%lldLL",(long long)TGSpeedo::kRed).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TImage),-1,-1,2,"fImage=",0,"image used as background");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TImage),-1,-1,2,"fImage2=",0,"intermediate image used as background");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,2,"fBase=",0,"picture used as background");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fTextFS=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fCounterFS=",0,"font structures for text rendering");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCounter=",0,"small odo meter (4 digits)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fPicName=",0,"name of picture used as background");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fLabel1=",0,"main label (first line)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fLabel2=",0,"main label (second line)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fDisplay1=",0,"first line in the small display");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fDisplay2=",0,"second line in the small display");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAngle=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fValue=",0,"needle angle and corresponding value");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPeakVal=",0,"maximum peak mark");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMeanVal=",0,"mean value mark");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAngleMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAngleMax=",0,"needle min and max angle");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScaleMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScaleMax=",0,"needle min and max scale");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fThreshold[3]=",0,"glowing thresholds");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedocLcLEGlowColor),-1,-1,2,"fThresholdColor[3]=",0,"glowing threshold colors");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fThresholdActive=",0,"kTRUE if glowing threhsholds are active");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPeakMark=",0,"kTRUE if peak mark is active");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMeanMark=",0,"kTRUE if mean mark is active");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDragWindow */
static void G__setup_memvarTGDragWindow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow));
   { TGDragWindow *p; p=(TGDragWindow*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-2,2,"fgDefaultCursor=",0,"Default Cursor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-1,2,"fInput=",0,"Input Window");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPic=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fMask=",0,"Pixmaps used as Window shape");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fPw=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fPh=",0,"Hot point coordinates (x and y)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTable */
static void G__setup_memvarTGTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable));
   { TGTable *p; p=(TGTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TObjArray),-1,-1,2,"fRows=",0,"Array of rows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TObjArray),-1,-1,2,"fRowHeaders=",0,"Array of row headers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TObjArray),-1,-1,2,"fColumnHeaders=",0,"Array of column headers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader),-1,-1,2,"fTableHeader=",0,"Top left element of the table");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReadOnly=",0,"Table readonly state");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fSelectColor=",0,"Select Color");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTMode=",0,"Text justify mode");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAllData=",0,"Is the data bigger than the table");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TTableRange),-1,-1,2,"fCurrentRange=",0,"Range of data currently loaded");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TTableRange),-1,-1,2,"fDataRange=",0,"Full range of the data set");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TTableRange),-1,-1,2,"fGotoRange=",0,"Range used by Goto frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTableFrame),-1,-1,2,"fTableFrame=",0,"Container for the frames ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),-1,-1,2,"fCanvas=",0,"Canvas that will contains the cells");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCellWidth=",0,"Default cell width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCellHeight=",0,"Default cell width");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),-1,-1,2,"fCHdrFrame=",0,"Frame that contains the row headers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame),-1,-1,2,"fRHdrFrame=",0,"Frame that contains the row headers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fRangeFrame=",0,"Frame that contains the top part");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fTopFrame=",0,"Frame that contains the top part");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fTopExtraFrame=",0,"Dev idea");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fBottomFrame=",0,"Frame that contains the bottom part");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fButtonFrame=",0,"Contains the buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,2,"fNextButton=",0,"Button to view next chunk");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,2,"fPrevButton=",0,"Button to view previous chunk");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,2,"fUpdateButton=",0,"Button to update current view");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextButton),-1,-1,2,"fGotoButton=",0,"Button to goto a new range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fFirstCellLabel=",0,"Label for the range frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fRangeLabel=",0,"Label for the range frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fFirstCellEntry=",0,"TextEntry for the range frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fRangeEntry=",0,"TextEntry for the range frame");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fOddRowBackground=",0,"Background color for odd numbered rows");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fEvenRowBackground=",0,"Background color for even numbered rows");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fHeaderBackground=",0,"Background color for headers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,2,"fCellHintsList=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,2,"fRHdrHintsList=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,2,"fCHdrHintsList=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,2,"fMainHintsList=",0,"List for all hints used in the main table frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TVirtualTableInterface),-1,-1,2,"fInterface=",0,"Interface to the data source");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTableCell */
static void G__setup_memvarTGTableCell(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell));
   { TGTableCell *p; p=(TGTableCell*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGString),-1,-1,2,"fLabel=",0,"Text as shown in the cell");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGToolTip),-1,-1,2,"fTip=",0,"Possible Tooltip");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReadOnly=",0,"Cell readonly state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnabled=",0,"Cell enabled state");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTMode=",0,"Text justify mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,2,"fImage=",0,"Image or icon");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTWidth=",0,"Label width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTHeight=",0,"Label heigth");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"Font of the label");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasOwnFont=",0,"Does the cell have it's own font");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"graphics context used to draw the cell");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fColumn=",0,"Column this cell belongs to");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fRow=",0,"Row this cell belongs to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTable),-1,-1,2,"fTable=",0,"TGTable that a cell belongs to");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-2,2,"fgDefaultGC=",0,"Default graphics context");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGFont),-1,-2,2,"fgDefaultFont=",0,"Default font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTableHeader */
static void G__setup_memvarTGTableHeader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader));
   { TGTableHeader *p; p=(TGTableHeader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui3LN_EHeaderType),-1,-1,2,"fType=",0,"Type of header");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWidth=",0,"Width for the column");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fHeight=",0,"Height of the row");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReadOnly=",0,"Cell readonly state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnabled=",0,"Cell enabled state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasOwnLabel=",0,"Flag on default or specific label usage");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTableFrame */
static void G__setup_memvarTGTableFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableFrame));
   { TGTableFrame *p; p=(TGTableFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fFrame=",0,"Composite frame used as a container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),-1,-1,2,"fCanvas=",0,"Pointer to the canvas that used this frame.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTableHeaderFrame */
static void G__setup_memvarTGTableHeaderFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame));
   { TGTableHeaderFrame *p; p=(TGTableHeaderFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX0=",0,"X coordinate of the header frame ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY0=",0,"Y coordinate of the header frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTable),-1,-1,2,"fTable=",0,"Table that this frame belongs to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTableRange */
static void G__setup_memvarTTableRange(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TTableRange));
   { TTableRange *p; p=(TTableRange*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fXtl)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fXtl=",0,"Top left X coordinate");
   G__memvar_setup((void*)((long)(&p->fYtl)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fYtl=",0,"Top left Y coordinate");
   G__memvar_setup((void*)((long)(&p->fXbr)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fXbr=",0,"Bottom right X coordinate");
   G__memvar_setup((void*)((long)(&p->fYbr)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fYbr=",0,"Bottom right Y coordinate");
   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__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSimpleTableInterface */
static void G__setup_memvarTGSimpleTableInterface(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface));
   { TGSimpleTableInterface *p; p=(TGSimpleTableInterface*)0x1000; if (p) { }
   G__memvar_setup((void*)0,68,2,0,-1,G__defined_typename("Double_t"),-1,4,"fData=",0,"Pointer to 2 dimensional array of Double_t");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNRows=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNColumns=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSimpleTable */
static void G__setup_memvarTGSimpleTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable));
   { TGSimpleTable *p; p=(TGSimpleTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGCommandPlugin */
static void G__setup_memvarTGCommandPlugin(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin));
   { TGCommandPlugin *p; p=(TGCommandPlugin*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPid=",0,"current process id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fHf=",0,"horizontal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLabel),-1,-1,2,"fLabel=",0,"\"command :\" label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGComboBox),-1,-1,2,"fComboCmd=",0,"commands combobox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextEntry),-1,-1,2,"fCommand=",0,"command text entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextBuffer),-1,-1,2,"fCommandBuf=",0,"command text buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTextView),-1,-1,2,"fStatus=",0,"output capture view");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TTimer),-1,-1,2,"fTimer=",0,"for local/remote update");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRootBrowser */
static void G__setup_memvarTRootBrowser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser));
   { TRootBrowser *p; p=(TRootBrowser*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH0=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH3=",0,"Layout hints, part 1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH4=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH5=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH6=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints),-1,-1,2,"fLH7=",0,"Layout hints, part 2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTab),-1,-1,2,"fTabLeft=",0,"Left Tab");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTab),-1,-1,2,"fTabRight=",0,"Right Tab");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTab),-1,-1,2,"fTabBottom=",0,"Bottom Tab");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTab),-1,-1,2,"fEditTab=",0,"Tab in \"Edit\" mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEditPos=",0,"Id of tab in \"Edit\" mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEditSubPos=",0,"Id of subtab in \"Edit\" mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVerticalFrame),-1,-1,2,"fVf=",0,"Vertical frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fHf=",0,"Horizontal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fH1=",0,"Horizontal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fH2=",0,"Horizontal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVerticalFrame),-1,-1,2,"fV1=",0,"Vertical frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVerticalFrame),-1,-1,2,"fV2=",0,"Vertical frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGVSplitter),-1,-1,2,"fVSplitter=",0,"Vertical splitter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHSplitter),-1,-1,2,"fHSplitter=",0,"Horizontal splitter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fEditFrame=",0,"Frame in \"Edit\" mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fTopMenuFrame=",0,"Top menu frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fPreMenuFrame=",0,"First (owned) menu frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fMenuFrame=",0,"Shared menu frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fToolbarFrame=",0,"Toolbar frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar),-1,-1,2,"fMenuBar=",0,"Main (owned) menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuFile=",0,"\"File\" popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuExecPlugin=",0,"\"Exec Plugin\" popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu),-1,-1,2,"fMenuHelp=",0,"\"Browser Help\" popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame),-1,-1,2,"fActMenuBar=",0,"Actual (active) menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp),-1,-1,2,"fActBrowser=",0,"Actual (active) browser imp");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,2,"fBrowsers=",0,"List of (sub)browsers");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TList),-1,-1,2,"fPlugins=",0,"List of plugins");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar),-1,-1,2,"fStatusBar=",0,"Status bar");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbInitPlugins=",0,"Number of initial plugins (from .rootrc)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbTab[3]=",0,"Number of tab elements (for each Tab)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCrTab[3]=",0,"Actual (active) tab elements (for each Tab)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPid=",0,"Current process id");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowCloseTab=",0,"kTRUE to show close icon on tab elements");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowsercLcLEInsertPosition),-1,-2,1,G__FastAllocString(2048).Format("kLeft=%lldLL",(long long)TRootBrowser::kLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowsercLcLEInsertPosition),-1,-2,1,G__FastAllocString(2048).Format("kRight=%lldLL",(long long)TRootBrowser::kRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowsercLcLEInsertPosition),-1,-2,1,G__FastAllocString(2048).Format("kBottom=%lldLL",(long long)TRootBrowser::kBottom).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFileBrowser */
static void G__setup_memvarTGFileBrowser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser));
   { TGFileBrowser *p; p=(TGFileBrowser*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser),-1,-1,2,"fNewBrowser=",0,"Pointer back to the Browser");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fTopFrame=",0,"Top horizontal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGHorizontalFrame),-1,-1,2,"fBotFrame=",0,"Bottom horizontal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas),-1,-1,2,"fCanvas=",0,"Canvas for the list tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListTree),-1,-1,2,"fListTree=",0,"Main list tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListTreeItem),-1,-1,2,"fListLevel=",0,"Current list tree level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListTreeItem),-1,-1,2,"fCurrentDir=",0,"Current (list tree) directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGListTreeItem),-1,-1,2,"fRootDir=",0,"Root (list tree) directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGComboBox),-1,-1,2,"fDrawOption=",0,"Draw options combobox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGComboBox),-1,-1,2,"fFileType=",0,"File type combobox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TContextMenu),-1,-1,2,"fContextMenu=",0,"pointer to context menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPictureButton),-1,-1,2,"fSortButton=",0,"\"Sort\" button ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGPictureButton),-1,-1,2,"fRefreshButton=",0,"\"Refresh\" button ");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,2,"fRootIcon=",0,"Root files icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,2,"fFileIcon=",0,"System files icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,2,"fCachedPic=",0,"Cached picture");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,2,"fCachedPicName=",0,"Cached picture name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TRegexp),-1,-1,2,"fFilter=",0,"Regular expression used to filter files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TSystemDirectory),-1,-1,2,"fDir=",0,"Actual (selected) system directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TSystemFile),-1,-1,2,"fFile=",0,"Actual (selected) system file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fGroupSize=",0,"total number of items when icon box switched to \"global view\" mode");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fNKeys=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fCnt=",0,"Counters for keys inside a Root file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGrouped=",0,"kTRUE if Root file content (keys) is grouped");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowHidden=",0,"kTRUE to display hidden files");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDblClick=",0,"kTRUE if user double-clicked on a list tree item");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgR),G__defined_typename("sLTI_t"),-1,2,"fSortedItems=",0,"List of sorted list-tree items.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBrowserPlugin */
static void G__setup_memvarTBrowserPlugin(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin));
   { TBrowserPlugin *p; p=(TBrowserPlugin*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fTab)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fTab=",0,"Tab number");
   G__memvar_setup((void*)((long)(&p->fSubTab)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSubTab=",0,"Tab element number");
   G__memvar_setup((void*)((long)(&p->fCommand)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TString),-1,-1,1,"fCommand=",0,"Command to be executed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRectMap */
static void G__setup_memvarTGRectMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap));
   { TGRectMap *p; p=(TGRectMap*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fX=",0,"x position");
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fY=",0,"y position");
   G__memvar_setup((void*)((long)(&p->fW)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fW=",0,"width");
   G__memvar_setup((void*)((long)(&p->fH)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fH=",0,"height");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSplitTool */
static void G__setup_memvarTGSplitTool(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool));
   { TGSplitTool *p; p=(TGSplitTool*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,4,"fWindow=",0,"frame to which tool tip is associated");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGGC),-1,-1,4,"fRectGC=",0,"rectangles drawing context");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TMap),-1,-1,4,"fMap=",0,"map of rectangles/subframes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TContextMenu),-1,-1,4,"fContextMenu=",0,"Context menu for the splitter");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fX=",0,"X position in fWindow where to popup");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fY=",0,"Y position in fWindow where to popup");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSplitFrame */
static void G__setup_memvarTGSplitFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame));
   { TGSplitFrame *p; p=(TGSplitFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGFrame),-1,-1,2,"fFrame=",0,"Pointer to the embedded frame (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGTransientFrame),-1,-1,2,"fUndocked=",0,"Main frame used when \"undocking\" frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGSplitter),-1,-1,2,"fSplitter=",0,"Pointer to the (H/V) Splitter (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),-1,-1,2,"fFirst=",0,"Pointer to the first child (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame),-1,-1,2,"fSecond=",0,"Pointer to the second child (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool),-1,-1,2,"fSplitTool=",0,"SplitFrame Tool");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWRatio=",0,"Width ratio between the first child and this");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fHRatio=",0,"Height ratio between the first child and this");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGShapedFrame */
static void G__setup_memvarTGShapedFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame));
   { TGShapedFrame *p; p=(TGShapedFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui3LN_TGPicture),-1,-1,2,"fBgnd=",0,"picture used as background/shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TImage),-1,-1,2,"fImage=",0,"image used as background/shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGEventHandler */
static void G__setup_memvarTGEventHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler));
   { TGEventHandler *p; p=(TGEventHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsActive=",0,"kTRUE if handler is active, kFALSE if not active");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGWindow),-1,-1,4,"fWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TObject),-1,-1,4,"fObject=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Gui3() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTRootGuiFactory(void) {
   /* TRootGuiFactory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory));
   G__memfunc_setup("TRootGuiFactory",1525,G__G__Gui3_120_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"Root\"' name C - - 10 '\"ROOT GUI Factory\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateApplicationImp",2030,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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("Class",502,G__G__Gui3_120_0_10, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootGuiFactory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_120_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootGuiFactory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_120_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootGuiFactory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_120_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootGuiFactory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_120_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_120_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootGuiFactory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_120_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootGuiFactory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_120_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootGuiFactory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_120_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootGuiFactory::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRootGuiFactory", 1525, G__G__Gui3_120_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory), -1, 0, 1, 1, 1, 0, "u 'TRootGuiFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRootGuiFactory", 1651, G__G__Gui3_120_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui3_120_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TRootGuiFactory), -1, 1, 1, 1, 1, 0, "u 'TRootGuiFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootApplication(void) {
   /* TRootApplication */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication));
   G__memfunc_setup("TRootApplication",1644,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"I - 'Int_t' 0 - argc C - - 2 - argv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRootApplication",1644,G__G__Gui3_123_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication), -1, 0, 3, 1, 1, 0, 
"C - - 10 - appClassName I - 'Int_t' 0 - argc "
"C - - 2 - argv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Client",607,G__G__Gui3_123_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGClient), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Iconify",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCmdThread",1064,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Open",402,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Raise",500,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Lower",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_123_0_13, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootApplication::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_123_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootApplication::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_123_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootApplication::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_123_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootApplication::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_123_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__Gui3_123_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootApplication::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_123_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootApplication::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_123_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootApplication::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_123_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootApplication::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRootApplication", 1644, G__G__Gui3_123_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication), -1, 0, 1, 1, 1, 0, "u 'TRootApplication' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRootApplication", 1770, G__G__Gui3_123_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__Gui3_123_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TRootApplication), -1, 1, 1, 1, 1, 0, "u 'TRootApplication' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDNDData(void) {
   /* TDNDData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TDNDData));
   G__memfunc_setup("TDNDData",676,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TDNDData), -1, 0, 1, 1, 4, 0, "u 'TDNDData' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TDNDData), -1, 1, 1, 1, 4, 0, "u 'TDNDData' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TDNDData",676,G__G__Gui3_215_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TDNDData), -1, 0, 4, 1, 1, 0, 
"k - 'Atom_t' 0 'kNone' dt Y - - 0 '0' d "
"i - 'Int_t' 0 '0' len k - 'Atom_t' 0 'kNone' act", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_215_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDNDData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_215_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDNDData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_215_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDNDData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_215_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDNDData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_215_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_215_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDNDData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_215_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDNDData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_215_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDNDData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_215_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDNDData::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDNDData", 802, G__G__Gui3_215_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDockableFrame(void) {
   /* TGDockableFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame));
   G__memfunc_setup("TGDockableFrame",1435,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame), -1, 0, 1, 1, 4, 0, "u 'TGDockableFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame), -1, 1, 1, 1, 4, 0, "u 'TGDockableFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGDockableFrame",1435,G__G__Gui3_241_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFrame",756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 - hints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - - l - 'Long_t' 0 - - "
"l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Docked",586,G__G__Gui3_241_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Undocked",813,G__G__Gui3_241_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("UndockContainer",1543,G__G__Gui3_241_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DockContainer",1316,G__G__Gui3_241_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kTRUE' del", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideContainer",1309,G__G__Gui3_241_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowContainer",1348,G__G__Gui3_241_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableUndock",1195,G__G__Gui3_241_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableUndock",1195,G__G__Gui3_241_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableHide",961,G__G__Gui3_241_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableHide",961,G__G__Gui3_241_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWindowName",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsUndocked",1001,G__G__Gui3_241_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHidden",776,G__G__Gui3_241_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFixedSize",1095,G__G__Gui3_241_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixedSize",1207,G__G__Gui3_241_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContainer",1219,G__G__Gui3_241_0_21, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUndocked",1101,G__G__Gui3_241_0_22, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_241_0_24, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDockableFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_241_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockableFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_241_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDockableFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_241_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDockableFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_241_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__Gui3_241_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockableFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_241_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDockableFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_241_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockableFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_241_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDockableFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDockableFrame", 1561, G__G__Gui3_241_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDNDManager(void) {
   /* TGDNDManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager));
   G__memfunc_setup("TGDNDManager",1068,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager), -1, 0, 1, 1, 4, 0, "u 'TGDNDManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager), -1, 1, 1, 1, 4, 0, "u 'TGDNDManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitAtoms",920,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRootProxy",1254,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindWindow",1017,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Window_t"), 0, 4, 1, 2, 0, 
"k - 'Window_t' 0 - root i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y i - 'Int_t' 0 - maxd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDNDAware",898,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"k - 'Window_t' 0 - win K - 'Atom_t' 0 '0' typelist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTopLevel",999,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "k - 'Window_t' 0 - win", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendDNDEnter",1118,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "k - 'Window_t' 0 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendDNDLeave",1101,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "k - 'Window_t' 0 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendDNDPosition",1461,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"k - 'Window_t' 0 - target i - - 0 - x "
"i - - 0 - y k - 'Atom_t' 0 - action "
"k - 'Time_t' 0 - timestamp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendDNDStatus",1252,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"k - 'Window_t' 0 - target k - 'Atom_t' 0 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendDNDDrop",1013,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "k - 'Window_t' 0 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendDNDFinished",1418,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "k - 'Window_t' 0 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDEnter",1312,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"k - 'Window_t' 0 - src l - - 0 - vers "
"K - 'Atom_t' 0 - dataTypes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDLeave",1295,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "k - 'Window_t' 0 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDPosition",1655,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 2, 0, 
"k - 'Window_t' 0 - src i - - 0 - x_root "
"i - - 0 - y_root k - 'Atom_t' 0 - action "
"k - 'Time_t' 0 - timestamp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDStatus",1446,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"k - 'Window_t' 0 - from i - - 0 - accepted "
"u 'Rectangle_t' - 0 - skip k - 'Atom_t' 0 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDDrop",1207,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"k - 'Window_t' 0 - src k - 'Time_t' 0 - timestamp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDFinished",1612,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "k - 'Window_t' 0 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGDNDManager",1068,G__G__Gui3_242_0_20, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager), -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - toplevel K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleClientMessage",1904,G__G__Gui3_242_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSelectionRequest",2267,G__G__Gui3_242_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSelection",1522,G__G__Gui3_242_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMainFrame",1168,G__G__Gui3_242_0_25, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMainFrame",1180,G__G__Gui3_242_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - main", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDragPixmap",1305,G__G__Gui3_242_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Pixmap_t' 0 - pic k - 'Pixmap_t' 0 - mask "
"i - 'Int_t' 0 - hot_x i - 'Int_t' 0 - hot_y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRootProxy",1266,G__G__Gui3_242_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveRootProxy",1588,G__G__Gui3_242_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartDrag",908,G__G__Gui3_242_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - src i - 'Int_t' 0 - x_root "
"i - 'Int_t' 0 - y_root k - 'Window_t' 0 'kNone' grabWin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Drag",382,G__G__Gui3_242_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x_root i - 'Int_t' 0 - y_root "
"k - 'Atom_t' 0 - action k - 'Time_t' 0 - timestamp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Drop",405,G__G__Gui3_242_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndDrag",661,G__G__Gui3_242_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDragging",991,G__G__Gui3_242_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSource",913,G__G__Gui3_242_0_35, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTarget",903,G__G__Gui3_242_0_36, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeList",1118,G__G__Gui3_242_0_37, 75, -1, G__defined_typename("Atom_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDNDAware",998,G__G__Gui3_242_0_38, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDAware) ), 0);
   G__memfunc_setup("GetDNDSelection",1436,G__G__Gui3_242_0_39, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDSelection) ), 0);
   G__memfunc_setup("GetDNDProxy",1048,G__G__Gui3_242_0_40, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDProxy) ), 0);
   G__memfunc_setup("GetDNDEnter",1012,G__G__Gui3_242_0_41, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDEnter) ), 0);
   G__memfunc_setup("GetDNDLeave",995,G__G__Gui3_242_0_42, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDLeave) ), 0);
   G__memfunc_setup("GetDNDPosition",1355,G__G__Gui3_242_0_43, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDPosition) ), 0);
   G__memfunc_setup("GetDNDStatus",1146,G__G__Gui3_242_0_44, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDStatus) ), 0);
   G__memfunc_setup("GetDNDDrop",907,G__G__Gui3_242_0_45, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDDrop) ), 0);
   G__memfunc_setup("GetDNDFinished",1312,G__G__Gui3_242_0_46, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDFinished) ), 0);
   G__memfunc_setup("GetDNDVersion",1244,G__G__Gui3_242_0_47, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDVersion) ), 0);
   G__memfunc_setup("GetDNDActionCopy",1519,G__G__Gui3_242_0_48, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionCopy) ), 0);
   G__memfunc_setup("GetDNDActionMove",1515,G__G__Gui3_242_0_49, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionMove) ), 0);
   G__memfunc_setup("GetDNDActionLink",1506,G__G__Gui3_242_0_50, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionLink) ), 0);
   G__memfunc_setup("GetDNDActionAsk",1395,G__G__Gui3_242_0_51, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionAsk) ), 0);
   G__memfunc_setup("GetDNDActionPrivate",1839,G__G__Gui3_242_0_52, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionPrivate) ), 0);
   G__memfunc_setup("GetDNDTypeList",1332,G__G__Gui3_242_0_53, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDTypeList) ), 0);
   G__memfunc_setup("GetDNDActionList",1520,G__G__Gui3_242_0_54, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionList) ), 0);
   G__memfunc_setup("GetDNDActionDescrip",1822,G__G__Gui3_242_0_55, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetDNDActionDescrip) ), 0);
   G__memfunc_setup("GetXCDNDData",1035,G__G__Gui3_242_0_56, 107, -1, G__defined_typename("Atom_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Atom_t (*)())(&TGDNDManager::GetXCDNDData) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui3_242_0_57, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDNDManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_242_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDNDManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_242_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDNDManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_242_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDNDManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_242_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_242_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDNDManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_242_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDNDManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_242_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDNDManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_242_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDNDManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDNDManager", 1194, G__G__Gui3_242_0_69, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootCanvas(void) {
   /* TRootCanvas */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas));
   G__memfunc_setup("TRootCanvas",1108,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas), -1, 0, 1, 1, 4, 0, "u 'TRootCanvas' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas), -1, 1, 1, 1, 4, 0, "u 'TRootCanvas' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CreateCanvas",1200,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateEditor",1211,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerButton",2155,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerDoubleClick",2608,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerConfigure",2449,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerKey",1816,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerMotion",2149,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerExpose",2147,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleContainerCrossing",2359,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDDrop",1207,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TDNDData' - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDPosition",1655,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Atom_t"), 0, 5, 1, 4, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"k - 'Atom_t' 0 - action i - 'Int_t' 0 - xroot "
"i - 'Int_t' 0 - yroot", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDEnter",1312,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Atom_t"), 0, 1, 1, 4, 0, "K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDLeave",1295,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TRootCanvas",1108,G__G__Gui3_244_0_16, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas), -1, 0, 4, 1, 1, 0, 
"U 'TCanvas' - 0 '0' c C - - 10 '\"ROOT Canvas\"' name "
"h - 'UInt_t' 0 '500' width h - 'UInt_t' 0 '300' height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRootCanvas",1108,G__G__Gui3_244_0_17, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootCanvas), -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("AdjustSize",1030,G__G__Gui3_244_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForceUpdate",1106,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FitCanvas",895,G__G__Gui3_244_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EventInfo",910,G__G__Gui3_244_0_22, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py U 'TObject' - 0 - selected", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowGeometry",1764,(G__InterfaceMethod) NULL,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("GetCwidth",899,G__G__Gui3_244_0_24, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheight",988,G__G__Gui3_244_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Iconify",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitWindow",1036,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintCanvas",1129,G__G__Gui3_244_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RaiseWindow",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowPosition",1785,(G__InterfaceMethod) NULL,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__InterfaceMethod) NULL,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__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - newTitle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCanvasSize",1315,(G__InterfaceMethod) NULL,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("SetStatusText",1365,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' txt i - 'Int_t' 0 '0' partidx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMenuBar",1099,(G__InterfaceMethod) NULL,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__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowEditor",1032,(G__InterfaceMethod) NULL,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__InterfaceMethod) NULL,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__InterfaceMethod) NULL,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__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasMenuBar",966,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasStatusBar",1205,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasToolBar",975,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasToolTips",1114,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMenuBar",970,G__G__Gui3_244_0_46, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuBarItemLayout",2007,G__G__Gui3_244_0_47, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGLayoutHints), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatusBar",1209,G__G__Gui3_244_0_48, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetToolDock",1087,G__G__Gui3_244_0_49, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGDockableFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReallyDelete",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_244_0_53, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootCanvas::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_244_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootCanvas::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_244_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootCanvas::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_244_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootCanvas::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_244_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_244_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootCanvas::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_244_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootCanvas::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_244_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootCanvas::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_244_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootCanvas::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootCanvas", 1234, G__G__Gui3_244_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootBrowserLite(void) {
   /* TRootBrowserLite */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite));
   G__memfunc_setup("CreateBrowser",1336,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ListTreeHighlight",1732,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteListTreeItem",1806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighlightListLevel",1836,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToHistory",1214,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IconBoxAction",1296,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chdir",490,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplayDirectory",1675,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplayTotal",1242,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - selected", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewMode",1100,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - new_mode g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToSystemDirectory",1789,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - dirname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateDrawOption",1642,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Search",598,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BrowseTextFile",1431,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideTextEdit",1189,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMacroButtons",1666,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HistoryBackward",1553,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HistoryForward",1479,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearHistory",1241,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRootBrowserLite",1642,G__G__Gui3_256_0_20, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite), -1, 0, 4, 1, 1, 0, 
"U 'TBrowser' - 0 '0' b C - - 10 '\"ROOT Browser\"' title "
"h - 'UInt_t' 0 '800' width h - 'UInt_t' 0 '500' height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRootBrowserLite",1642,G__G__Gui3_256_0_21, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowserLite), -1, 0, 6, 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", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Gui3_256_0_22, 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, 1);
   G__memfunc_setup("AddToBox",757,G__G__Gui3_256_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddToTree",860,G__G__Gui3_256_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 - name "
"i - 'Int_t' 0 '-1' check", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddCheckBox",1040,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckObjectItem",1476,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveCheckBox",1397,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BrowseObj",909,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteDefaultAction",2038,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui3_256_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Checked",679,G__G__Gui3_256_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - check", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Iconify",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeBrowser",1366,G__G__Gui3_256_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowToolBar",1108,G__G__Gui3_256_0_36, 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__Gui3_256_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaults",1124,G__G__Gui3_256_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' iconStyle C - - 10 '0' sortBy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatusText",1365,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - txt i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListTree",1100,G__G__Gui3_256_0_42, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGListTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIconBox",978,G__G__Gui3_256_0_43, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFileContainer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatusBar",1209,G__G__Gui3_256_0_44, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuBar",970,G__G__Gui3_256_0_45, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetToolBar",979,G__G__Gui3_256_0_46, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGToolBar), -1, 0, 0, 1, 1, 8, "", (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("SetSortMode",1113,G__G__Gui3_256_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - new_mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMainFrame",1168,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReallyDelete",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecMacro",887,G__G__Gui3_256_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InterruptMacro",1471,G__G__Gui3_256_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewBrowser",1038,G__G__Gui3_256_0_56, 85, G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp), -1, 0, 5, 3, 1, 0, 
"U 'TBrowser' - 0 '0' b C - - 10 '\"ROOT Browser\"' title "
"h - 'UInt_t' 0 '800' width h - 'UInt_t' 0 '500' height "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) G__func2void( (TBrowserImp* (*)(TBrowser*, const char*, UInt_t, UInt_t, Option_t*))(&TRootBrowserLite::NewBrowser) ), 0);
   G__memfunc_setup("NewBrowser",1038,G__G__Gui3_256_0_57, 85, G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp), -1, 0, 7, 3, 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*) G__func2void( (TBrowserImp* (*)(TBrowser*, const char*, Int_t, Int_t, UInt_t, UInt_t, Option_t*))(&TRootBrowserLite::NewBrowser) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui3_256_0_58, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootBrowserLite::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_256_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootBrowserLite::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_256_0_60, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootBrowserLite::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_256_0_61, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootBrowserLite::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_256_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_256_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootBrowserLite::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_256_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootBrowserLite::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_256_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootBrowserLite::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_256_0_69, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootBrowserLite::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootBrowserLite", 1768, G__G__Gui3_256_0_70, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootDialog(void) {
   /* TRootDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog));
   G__memfunc_setup("TRootDialog",1096,G__G__Gui3_268_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog), -1, 0, 7, 1, 1, 0, 
"U 'TRootContextMenu' - 0 '0' cmenu U 'TGWindow' - 10 '0' main "
"C - - 10 '\"ROOT Dialog\"' title g - 'Bool_t' 0 'kTRUE' okB "
"g - 'Bool_t' 0 'kTRUE' cancelB g - 'Bool_t' 0 'kFALSE' applyB "
"g - 'Bool_t' 0 'kTRUE' helpB", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Gui3_268_0_2, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - argname C - - 10 - value "
"C - - 10 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameters",1332,G__G__Gui3_268_0_3, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Popup",532,G__G__Gui3_268_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TabPressed",1005,G__G__Gui3_268_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_268_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_268_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_268_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_268_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_268_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__Gui3_268_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_268_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_268_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_268_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootDialog", 1222, G__G__Gui3_268_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootContextMenu(void) {
   /* TRootContextMenu */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu));
   G__memfunc_setup("TRootContextMenu",1650,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu), -1, 0, 1, 1, 4, 0, "u 'TRootContextMenu' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu), -1, 1, 1, 1, 4, 0, "u 'TRootContextMenu' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMenu",1001,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObject' - 0 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRootContextMenu",1650,G__G__Gui3_269_0_4, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootContextMenu), -1, 0, 2, 1, 1, 0, 
"U 'TContextMenu' - 0 '0' c C - - 10 '\"ROOT Context Menu\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplayPopup",1258,(G__InterfaceMethod) NULL,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("Dialog",592,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TMethod' - 0 - method", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dialog",592,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - object U 'TFunction' - 0 - function", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawEntry",928,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMenuEntry' - 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDialog",880,G__G__Gui3_269_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TRootDialog), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OnlineHelp",1006,G__G__Gui3_269_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindHierarchy",1312,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu), -1, 0, 2, 1, 2, 0, 
"C - - 10 - commentstring u 'TString' - 1 - last_component", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEntrySorted",1420,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"U 'TGPopupMenu' - 0 - current C - - 10 - s "
"i - 'Int_t' 0 - id Y - - 0 '0' ud "
"U 'TGPicture' - 10 '0' p g - 'Bool_t' 0 'kTRUE' sorted", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_269_0_18, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootContextMenu::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_269_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootContextMenu::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_269_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootContextMenu::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_269_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootContextMenu::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_269_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__Gui3_269_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootContextMenu::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_269_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootContextMenu::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_269_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootContextMenu::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_269_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootContextMenu::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootContextMenu", 1776, G__G__Gui3_269_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootControlBar(void) {
   /* TRootControlBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar));
   G__memfunc_setup("TRootControlBar",1518,G__G__Gui3_271_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootControlBar), -1, 0, 4, 1, 1, 0, 
"U 'TControlBar' - 0 '0' c C - - 10 '\"ROOT Control Bar\"' title "
"i - 'Int_t' 0 '-999' x i - 'Int_t' 0 '-999' y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidgets",1015,G__G__Gui3_271_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReallyDelete",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetButtonState",1449,G__G__Gui3_271_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - label i - 'Int_t' 0 '0' state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetButtonWidth",1448,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - width", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fontName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - colorName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_271_0_13, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootControlBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_271_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootControlBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_271_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootControlBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_271_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootControlBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_271_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__Gui3_271_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootControlBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_271_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootControlBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_271_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootControlBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_271_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootControlBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootControlBar", 1644, G__G__Gui3_271_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootHelpDialog(void) {
   /* TRootHelpDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog));
   G__memfunc_setup("TRootHelpDialog",1489,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog), -1, 0, 1, 1, 4, 0, "u 'TRootHelpDialog' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog), -1, 1, 1, 1, 4, 0, "u 'TRootHelpDialog' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TRootHelpDialog",1489,G__G__Gui3_273_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootHelpDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' main C - - 10 '\"ROOT Help Dialog\"' title "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__Gui3_273_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - helpText", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddText",686,G__G__Gui3_273_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - helpText", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Popup",532,G__G__Gui3_273_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_273_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootHelpDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_273_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootHelpDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_273_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootHelpDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_273_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootHelpDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_273_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_273_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootHelpDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_273_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootHelpDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_273_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootHelpDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_273_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootHelpDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootHelpDialog", 1615, G__G__Gui3_273_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootEmbeddedCanvas(void) {
   /* TRootEmbeddedCanvas */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas));
   G__memfunc_setup("HandleContainerButton",2155,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleContainerDoubleClick",2608,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleContainerConfigure",2449,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleContainerKey",1816,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleContainerMotion",2149,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleContainerExpose",2147,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleContainerCrossing",2359,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TRootEmbeddedCanvas",1886,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas), -1, 0, 1, 1, 4, 0, "u 'TRootEmbeddedCanvas' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas), -1, 1, 1, 1, 4, 0, "u 'TRootEmbeddedCanvas' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TRootEmbeddedCanvas",1886,G__G__Gui3_283_0_10, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootEmbeddedCanvas), -1, 0, 6, 1, 1, 0, 
"C - - 10 '0' name U 'TGWindow' - 10 '0' p "
"h - 'UInt_t' 0 '10' w h - 'UInt_t' 0 '10' h "
"h - 'UInt_t' 0 'kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdoptCanvas",1108,G__G__Gui3_283_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvas",892,G__G__Gui3_283_0_12, 85, G__get_linked_tagnum(&G__G__Gui3LN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasWindowId",1697,G__G__Gui3_283_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoFit",988,G__G__Gui3_283_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoFit",1000,G__G__Gui3_283_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' fit", (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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDDrop",1207,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TDNDData' - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDPosition",1655,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"k - 'Atom_t' 0 - action i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDEnter",1312,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 1, 1, 1, 0, "K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDLeave",1295,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_283_0_21, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootEmbeddedCanvas::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_283_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootEmbeddedCanvas::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_283_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootEmbeddedCanvas::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_283_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootEmbeddedCanvas::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_283_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_283_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootEmbeddedCanvas::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_283_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootEmbeddedCanvas::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_283_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootEmbeddedCanvas::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_283_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootEmbeddedCanvas::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootEmbeddedCanvas", 2012, G__G__Gui3_283_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColorPalette(void) {
   /* TGColorPalette */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette));
   G__memfunc_setup("TGColorPalette",1385,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette), -1, 0, 1, 1, 4, 0, "u 'TGColorPalette' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette), -1, 1, 1, 1, 4, 0, "u 'TGColorPalette' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GotFocus",810,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LostFocus",930,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFocusHilite",1517,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGColorPalette",1385,G__G__Gui3_288_0_7, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '8' cols "
"i - 'Int_t' 0 '8' rows i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui3LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColors",926,G__G__Gui3_288_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "K - 'Pixel_t' 0 - colors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColor",811,G__G__Gui3_288_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ix k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentCellColor",1934,G__G__Gui3_288_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCellSize",1095,G__G__Gui3_288_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '20' w i - 'Int_t' 0 '17' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColorByIndex",1490,G__G__Gui3_288_0_16, 107, -1, G__defined_typename("Pixel_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentColor",1538,G__G__Gui3_288_0_17, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorSelected",1320,G__G__Gui3_288_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 '0' col", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_288_0_19, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColorPalette::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_288_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPalette::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_288_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColorPalette::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_288_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColorPalette::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_288_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__Gui3_288_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPalette::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_288_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorPalette::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_288_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPalette::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_288_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorPalette::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGColorPalette", 1511, G__G__Gui3_288_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColorPick(void) {
   /* TGColorPick */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawHScursor",1223,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawLcursor",1144,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHScursor",1125,(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, 0);
   G__memfunc_setup("SetLcursor",1046,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateImages",1194,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitImages",1002,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSliderColor",1422,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateCurrentColor",1861,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AllocColors",1117,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeColors",1012,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateDitheredImage",1888,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"k - 'Pixmap_t' 0 - image i - 'Int_t' 0 - which", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGColorPick",1057,G__G__Gui3_289_0_13, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPick), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '1' w "
"i - 'Int_t' 0 '1' h i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColor",811,G__G__Gui3_289_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentColor",1538,G__G__Gui3_289_0_17, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorSelected",1320,G__G__Gui3_289_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 '0' col", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_289_0_19, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColorPick::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_289_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPick::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_289_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColorPick::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_289_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColorPick::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_289_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__Gui3_289_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPick::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_289_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorPick::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_289_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPick::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_289_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorPick::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGColorPick", 1183, G__G__Gui3_289_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColorDialog(void) {
   /* TGColorDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog));
   G__memfunc_setup("TGColorDialog",1258,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog), -1, 0, 1, 1, 4, 0, "u 'TGColorDialog' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog), -1, 1, 1, 1, 4, 0, "u 'TGColorDialog' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("UpdateRGBentries",1592,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "K - 'Pixel_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateHLSentries",1604,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "K - 'Pixel_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGColorDialog",1258,G__G__Gui3_290_0_7, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorDialog), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGWindow' - 10 '0' m "
"I - 'Int_t' 0 '0' retc K - 'Pixel_t' 0 '0' color "
"g - 'Bool_t' 0 'kTRUE' wait", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPalette",1007,G__G__Gui3_290_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCustomPalette",1642,G__G__Gui3_290_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPalette), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorSelected",1320,G__G__Gui3_290_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoPreview",917,G__G__Gui3_290_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentColor",1550,G__G__Gui3_290_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColorInfo",1207,G__G__Gui3_290_0_13, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py U 'TObject' - 0 - selected", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_290_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColorDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_290_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_290_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColorDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_290_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColorDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_290_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__Gui3_290_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_290_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_290_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_290_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGColorDialog", 1384, G__G__Gui3_290_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColorFrame(void) {
   /* TGColorFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame));
   G__memfunc_setup("TGColorFrame",1157,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame), -1, 0, 1, 1, 4, 0, "u 'TGColorFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame), -1, 1, 1, 1, 4, 0, "u 'TGColorFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGColorFrame",1157,G__G__Gui3_296_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p k - 'Pixel_t' 0 '0' c "
"i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetActive",904,G__G__Gui3_296_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColor",799,G__G__Gui3_296_0_7, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_296_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColorFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_296_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_296_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColorFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_296_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColorFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_296_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__Gui3_296_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_296_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_296_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_296_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGColorFrame", 1283, G__G__Gui3_296_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTG16ColorSelector(void) {
   /* TG16ColorSelector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector));
   G__memfunc_setup("TG16ColorSelector",1602,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector), -1, 0, 1, 1, 4, 0, "u 'TG16ColorSelector' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector), -1, 1, 1, 1, 4, 0, "u 'TG16ColorSelector' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TG16ColorSelector",1602,G__G__Gui3_297_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TG16ColorSelector), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 '0' p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetActive",904,G__G__Gui3_297_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActive",892,G__G__Gui3_297_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_297_0_7, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TG16ColorSelector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_297_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TG16ColorSelector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_297_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TG16ColorSelector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_297_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TG16ColorSelector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_297_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_297_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TG16ColorSelector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_297_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TG16ColorSelector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_297_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TG16ColorSelector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_297_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TG16ColorSelector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TG16ColorSelector", 1728, G__G__Gui3_297_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColorPopup(void) {
   /* TGColorPopup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup));
   G__memfunc_setup("TGColorPopup",1198,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup), -1, 0, 1, 1, 4, 0, "u 'TGColorPopup' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup), -1, 1, 1, 1, 4, 0, "u 'TGColorPopup' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGColorPopup",1198,G__G__Gui3_298_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorPopup), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGWindow' - 10 '0' m "
"k - 'Pixel_t' 0 '0' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PlacePopup",1017,G__G__Gui3_298_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndPopup",811,G__G__Gui3_298_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreviewColor",1249,G__G__Gui3_298_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_298_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColorPopup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_298_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPopup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_298_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColorPopup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_298_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColorPopup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_298_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_298_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPopup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_298_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorPopup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_298_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorPopup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_298_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorPopup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGColorPopup", 1324, G__G__Gui3_298_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColorSelect(void) {
   /* TGColorSelect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawTriangle",1220,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGColorSelect",1274,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect), -1, 0, 1, 1, 4, 0, "u 'TGColorSelect' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect), -1, 1, 1, 1, 4, 0, "u 'TGColorSelect' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGColorSelect",1274,G__G__Gui3_299_0_5, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGColorSelect), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p k - 'Pixel_t' 0 '0' color "
"i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColor",811,G__G__Gui3_299_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Pixel_t' 0 - color g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColor",799,G__G__Gui3_299_0_9, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Enable",583,G__G__Gui3_299_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "*TOGGLE* *GETTER=IsEnabled", (void*) NULL, 0);
   G__memfunc_setup("Disable",692,G__G__Gui3_299_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDown",708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rename",600,G__G__Gui3_299_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnabled",983,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui3LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   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("ColorSelected",1320,G__G__Gui3_299_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 '0' color", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_299_0_18, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColorSelect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_299_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorSelect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_299_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColorSelect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_299_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColorSelect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_299_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__Gui3_299_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorSelect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_299_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorSelect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_299_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColorSelect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_299_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColorSelect::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGColorSelect", 1400, G__G__Gui3_299_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFontDialog(void) {
   /* TGFontDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog));
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"C - - 2 - fontList i - 'Int_t' 0 - cnt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontName",1080,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGFontDialog",1154,G__G__Gui3_301_0_5, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialog), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent U 'TGWindow' - 10 '0' t "
"U 'TGFontDialog::FontProp_t' - 0 '0' fontProp u 'TString' - 11 '\"\"' sample "
"C - - 2 '0' fontList g - 'Bool_t' 0 'kTRUE' wait", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFont",707,G__G__Gui3_301_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFont' - 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColor",811,G__G__Gui3_301_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlign",791,G__G__Gui3_301_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - align", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableAlign",1074,G__G__Gui3_301_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateStyleSize",1551,G__G__Gui3_301_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - family", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FontSelected",1216,G__G__Gui3_301_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - font", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("AlignSelected",1300,G__G__Gui3_301_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ColorSelected",1320,G__G__Gui3_301_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - c", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_301_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFontDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_301_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_301_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFontDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_301_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFontDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_301_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__Gui3_301_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_301_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFontDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_301_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_301_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFontDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFontDialog", 1280, G__G__Gui3_301_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFontDialogcLcLFontProp_t(void) {
   /* TGFontDialog::FontProp_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t));
   // automatic default constructor
   G__memfunc_setup("FontProp_t", 1035, G__G__Gui3_302_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FontProp_t", 1035, G__G__Gui3_302_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t), -1, 0, 1, 1, 1, 0, "u 'TGFontDialog::FontProp_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FontProp_t", 1161, G__G__Gui3_302_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__Gui3_302_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t), -1, 1, 1, 1, 1, 0, "u 'TGFontDialog::FontProp_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDockButton(void) {
   /* TGDockButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton));
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGDockButton",1176,G__G__Gui3_303_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDockButton), -1, 0, 2, 1, 1, 0, 
"U 'TGCompositeFrame' - 10 '0' p i - 'Int_t' 0 '1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_303_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDockButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_303_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_303_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDockButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_303_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDockButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_303_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__Gui3_303_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_303_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDockButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_303_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_303_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDockButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDockButton", 1302, G__G__Gui3_303_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDockHideButton(void) {
   /* TGDockHideButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGDockHideButton",1554,G__G__Gui3_304_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDockHideButton), -1, 0, 1, 1, 1, 0, "U 'TGCompositeFrame' - 10 '0' p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAspectRatio",1419,G__G__Gui3_304_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_304_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDockHideButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_304_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockHideButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_304_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDockHideButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_304_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDockHideButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_304_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_304_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockHideButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_304_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDockHideButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_304_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDockHideButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_304_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDockHideButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDockHideButton", 1680, G__G__Gui3_304_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGUndockedFrame(void) {
   /* TGUndockedFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame));
   G__memfunc_setup("TGUndockedFrame",1459,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame), -1, 0, 1, 1, 4, 0, "u 'TGUndockedFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame), -1, 1, 1, 1, 4, 0, "u 'TGUndockedFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGUndockedFrame",1459,G__G__Gui3_305_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGUndockedFrame), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGDockableFrame' - 0 '0' dockable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixSize",706,G__G__Gui3_305_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_305_0_6, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGUndockedFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_305_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGUndockedFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_305_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGUndockedFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_305_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGUndockedFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_305_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_305_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGUndockedFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_305_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGUndockedFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_305_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGUndockedFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_305_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGUndockedFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGUndockedFrame", 1585, G__G__Gui3_305_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiMenuBar(void) {
   /* TGMdiMenuBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar));
   G__memfunc_setup("AddFrames",871,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGMdiTitleIcon' - 0 - icon U 'TGMdiButtons' - 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveFrames",1228,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGMdiTitleIcon' - 0 - icon U 'TGMdiButtons' - 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowFrames",1023,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGMdiTitleIcon' - 0 - icon U 'TGMdiButtons' - 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideFrames",984,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGMdiTitleIcon' - 0 - icon U 'TGMdiButtons' - 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMdiMenuBar",1119,G__G__Gui3_310_0_5, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p i - 'Int_t' 0 '1' w "
"i - 'Int_t' 0 '20' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPopup",797,G__G__Gui3_310_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGHotString' - 0 - s U 'TGPopupMenu' - 0 - menu "
"U 'TGLayoutHints' - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuBar",970,G__G__Gui3_310_0_7, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMenuBar), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_310_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiMenuBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_310_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiMenuBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_310_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiMenuBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_310_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiMenuBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_310_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_310_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiMenuBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_310_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiMenuBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_310_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiMenuBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_310_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiMenuBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiMenuBar", 1245, G__G__Gui3_310_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiContainer(void) {
   /* TGMdiContainer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer));
   G__memfunc_setup("TGMdiContainer",1368,G__G__Gui3_311_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiContainer), -1, 0, 5, 1, 1, 0, 
"U 'TGMdiMainFrame' - 10 - p i - 'Int_t' 0 - w "
"i - 'Int_t' 0 - h h - 'UInt_t' 0 '0' options "
"k - 'ULong_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleConfigureNotify",2151,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui3LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_311_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiContainer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_311_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiContainer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_311_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiContainer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_311_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiContainer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_311_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_311_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiContainer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_311_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiContainer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_311_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiContainer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_311_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiContainer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiContainer", 1494, G__G__Gui3_311_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiDecorFrame(void) {
   /* TGMdiDecorFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame));
   G__memfunc_setup("TGMdiDecorFrame",1421,G__G__Gui3_312_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame), -1, 0, 7, 1, 1, 0, 
"U 'TGMdiMainFrame' - 0 - main U 'TGMdiFrame' - 0 - frame "
"i - 'Int_t' 0 - w i - 'Int_t' 0 - h "
"U 'TGGC' - 10 - boxGC h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleConfigureNotify",2151,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,G__G__Gui3_312_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Move",407,(G__InterfaceMethod) NULL,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("MoveResize",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"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("SetMdiButtons",1333,G__G__Gui3_312_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMdiButtons",1321,G__G__Gui3_312_0_9, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResizeMode",1315,G__G__Gui3_312_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kMdiDefaultResizeMode' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWindowName",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowIcon",1325,G__G__Gui3_312_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowName",1305,G__G__Gui3_312_0_13, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowIcon",1313,G__G__Gui3_312_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPicture), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCurrent",927,G__G__Gui3_312_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMinimized",1122,G__G__Gui3_312_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMaximized",1124,G__G__Gui3_312_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPreResizeX",1297,G__G__Gui3_312_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPreResizeY",1298,G__G__Gui3_312_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPreResizeWidth",1721,G__G__Gui3_312_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPreResizeHeight",1810,G__G__Gui3_312_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimizedX",1310,G__G__Gui3_312_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimizedY",1311,G__G__Gui3_312_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinUserPlacement",1916,G__G__Gui3_312_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,G__G__Gui3_312_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' cur", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDecorBorderWidth",1911,G__G__Gui3_312_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPreResizeX",1309,G__G__Gui3_312_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPreResizeY",1310,G__G__Gui3_312_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPreResizeWidth",1733,G__G__Gui3_312_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPreResizeHeight",1822,G__G__Gui3_312_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimizedX",1322,G__G__Gui3_312_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimizedY",1323,G__G__Gui3_312_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimize",834,G__G__Gui3_312_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Maximize",836,G__G__Gui3_312_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinUserPlacement",1928,G__G__Gui3_312_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' place", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMdiFrame",1061,G__G__Gui3_312_0_36, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitleBar",1079,G__G__Gui3_312_0_37, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperHR",966,G__G__Gui3_312_0_38, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerHR",963,G__G__Gui3_312_0_39, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperLeftCR",1356,G__G__Gui3_312_0_40, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerLeftCR",1353,G__G__Gui3_312_0_41, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperRightCR",1471,G__G__Gui3_312_0_42, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerRightCR",1468,G__G__Gui3_312_0_43, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftVR",851,G__G__Gui3_312_0_44, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightVR",966,G__G__Gui3_312_0_45, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_312_0_46, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiDecorFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_312_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiDecorFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_312_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiDecorFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_312_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiDecorFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_312_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_312_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiDecorFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_312_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiDecorFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_312_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiDecorFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_312_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiDecorFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiDecorFrame", 1547, G__G__Gui3_312_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiFrame(void) {
   /* TGMdiFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame));
   G__memfunc_setup("GetMdiHintsString",1719,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TString), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMdiFrame",928,G__G__Gui3_313_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGMdiMainFrame' - 0 - main i - 'Int_t' 0 - w "
"i - 'Int_t' 0 - h h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Move",407,(G__InterfaceMethod) NULL,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("CloseWindow",1134,G__G__Gui3_313_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Help",393,G__G__Gui3_313_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMdiHints",1100,G__G__Gui3_313_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - mdihints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMdiHints",1088,G__G__Gui3_313_0_7, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DontCallClose",1287,G__G__Gui3_313_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWindowName",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWindowIcon",1325,G__G__Gui3_313_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowName",1305,G__G__Gui3_313_0_11, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowIcon",1313,G__G__Gui3_313_0_12, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPicture), -1, 0, 0, 1, 1, 1, "", (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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_313_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_313_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_313_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_313_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_313_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__Gui3_313_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_313_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_313_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_313_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiFrame", 1054, G__G__Gui3_313_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiFrameList(void) {
   /* TGMdiFrameList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList));
   G__memfunc_setup("GetFrameId",952,G__G__Gui3_314_0_1, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecorFrame",1272,G__G__Gui3_314_0_2, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrev",701,G__G__Gui3_314_0_3, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNext",703,G__G__Gui3_314_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCyclePrev",1197,G__G__Gui3_314_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCycleNext",1199,G__G__Gui3_314_0_6, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameId",964,G__G__Gui3_314_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDecorFrame",1284,G__G__Gui3_314_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiDecorFrame' - 0 - decor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrev",713,G__G__Gui3_314_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrameList' - 0 - prev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNext",715,G__G__Gui3_314_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrameList' - 0 - next", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCyclePrev",1209,G__G__Gui3_314_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrameList' - 0 - prev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCycleNext",1211,G__G__Gui3_314_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrameList' - 0 - next", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_314_0_13, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiFrameList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_314_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiFrameList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_314_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiFrameList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_314_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiFrameList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_314_0_17, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_314_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__Gui3_314_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__Gui3_314_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__Gui3_314_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiFrameList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_314_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiFrameList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_314_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiFrameList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_314_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiFrameList::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TGMdiFrameList", 1340, G__G__Gui3_314_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TGMdiFrameList", 1340, G__G__Gui3_314_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 1, 1, 1, 0, "u 'TGMdiFrameList' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiFrameList", 1466, G__G__Gui3_314_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__Gui3_314_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 1, 1, 1, 1, 0, "u 'TGMdiFrameList' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiMainFrame(void) {
   /* TGMdiMainFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame));
   G__memfunc_setup("AddMdiFrame",1038,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGMdiFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveMdiFrame",1395,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TGMdiFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TGMdiFrameList' - 0 - newcurrent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecorFrame",1272,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame), -1, 0, 1, 1, 2, 8, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecorFrame",1272,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiDecorFrame), -1, 0, 1, 1, 2, 8, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateWinListMenu",1730,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMdiMainFrame",1317,G__G__Gui3_315_0_7, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMainFrame), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGMdiMenuBar' - 0 - menu "
"i - 'Int_t' 0 - w i - 'Int_t' 0 - h "
"h - 'UInt_t' 0 '0' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeMove",793,G__G__Gui3_315_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeSize",797,G__G__Gui3_315_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Restore",740,G__G__Gui3_315_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Maximize",836,G__G__Gui3_315_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Gui3_315_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Close",502,G__G__Gui3_315_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ContextHelp",1134,G__G__Gui3_315_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseAll",783,G__G__Gui3_315_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cascade",676,G__G__Gui3_315_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TileHorizontal",1464,G__G__Gui3_315_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TileVertical",1224,G__G__Gui3_315_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ArrangeFrames",1310,G__G__Gui3_315_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ArrangeMinimized",1638,G__G__Gui3_315_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CirculateUp",1121,G__G__Gui3_315_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CirculateDown",1332,G__G__Gui3_315_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrent",1027,G__G__Gui3_315_0_26, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMdiFrame",1061,G__G__Gui3_315_0_27, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrame), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContainer",1219,G__G__Gui3_315_0_28, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,G__G__Gui3_315_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - newcurrent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,G__G__Gui3_315_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - f", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("GetWinListMenu",1407,G__G__Gui3_315_0_31, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenu",693,G__G__Gui3_315_0_32, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiMenuBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowList",1332,G__G__Gui3_315_0_33, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiFrameList), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 'kFALSE' current", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfFrames",1692,G__G__Gui3_315_0_34, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResizeMode",1315,G__G__Gui3_315_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kMdiDefaultResizeMode' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBBox",651,G__G__Gui3_315_0_36, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGRectangle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimizedBBox",1585,G__G__Gui3_315_0_37, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGRectangle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowGeometry",1764,G__G__Gui3_315_0_38, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry), -1, 0, 1, 1, 1, 8, "U 'TGMdiFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConfigureWindow",1562,G__G__Gui3_315_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGMdiFrame' - 0 - f u 'TGMdiGeometry' - 1 - geom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMaximized",1124,G__G__Gui3_315_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMinimized",1122,G__G__Gui3_315_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGMdiFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FrameCreated",1187,G__G__Gui3_315_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("FrameClosed",1093,G__G__Gui3_315_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("FrameMaximized",1427,G__G__Gui3_315_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("FrameMinimized",1425,G__G__Gui3_315_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("FrameRestored",1331,G__G__Gui3_315_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("FramesArranged",1410,G__G__Gui3_315_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", "*SIGNAL*", (void*) NULL, 1);
   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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_315_0_49, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiMainFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_315_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiMainFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_315_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiMainFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_315_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiMainFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_315_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_315_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiMainFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_315_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiMainFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_315_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiMainFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_315_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiMainFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiMainFrame", 1443, G__G__Gui3_315_0_61, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiGeometry(void) {
   /* TGMdiGeometry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry));
   G__memfunc_setup("Class",502,G__G__Gui3_316_0_1, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiGeometry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_316_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiGeometry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_316_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiGeometry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_316_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiGeometry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_316_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_316_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui3_316_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui3_316_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_316_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiGeometry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_316_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiGeometry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_316_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiGeometry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_316_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiGeometry::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TGMdiGeometry", 1281, G__G__Gui3_316_0_13, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TGMdiGeometry", 1281, G__G__Gui3_316_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry), -1, 0, 1, 1, 1, 0, "u 'TGMdiGeometry' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiGeometry", 1407, G__G__Gui3_316_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui3_316_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGMdiGeometry), -1, 1, 1, 1, 1, 0, "u 'TGMdiGeometry' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiTitleIcon(void) {
   /* TGMdiTitleIcon */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGMdiTitleIcon",1344,G__G__Gui3_318_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - titlebar "
"U 'TGPicture' - 10 - pic i - 'Int_t' 0 - w "
"i - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDoubleClick",1677,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPopup",820,G__G__Gui3_318_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPopupMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_318_0_6, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiTitleIcon::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_318_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiTitleIcon::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_318_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiTitleIcon::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_318_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiTitleIcon::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_318_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_318_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiTitleIcon::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_318_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiTitleIcon::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_318_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiTitleIcon::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_318_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiTitleIcon::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiTitleIcon", 1470, G__G__Gui3_318_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiButtons(void) {
   /* TGMdiButtons */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons));
   G__memfunc_setup("TGMdiButtons",1188,G__G__Gui3_319_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - titlebar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetButton",924,G__G__Gui3_319_0_2, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPictureButton), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - no", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_319_0_3, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiButtons::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_319_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiButtons::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_319_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiButtons::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_319_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiButtons::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_319_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__Gui3_319_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiButtons::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_319_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiButtons::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_319_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiButtons::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_319_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiButtons::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiButtons", 1314, G__G__Gui3_319_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiTitleBar(void) {
   /* TGMdiTitleBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar));
   G__memfunc_setup("TGMdiTitleBar",1228,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleBar), -1, 0, 3, 1, 2, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - mdiwin "
"C - - 10 '\"Untitled\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LayoutButtons",1389,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"h - 'UInt_t' 0 - buttonmask g - 'Bool_t' 0 - isMinimized "
"g - 'Bool_t' 0 - isMaximized", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFrames",871,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGMdiTitleIcon' - 0 - icon U 'TGMdiButtons' - 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveFrames",1228,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGMdiTitleIcon' - 0 - icon U 'TGMdiButtons' - 0 - buttons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDoubleClick",1677,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitleBarColors",1717,G__G__Gui3_325_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - fore h - 'UInt_t' 0 - back "
"U 'TGFont' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetButtons",1039,G__G__Gui3_325_0_10, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiButtons), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWinIcon",983,G__G__Gui3_325_0_11, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiTitleIcon), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWinName",975,G__G__Gui3_325_0_12, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGLabel), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX0",424,G__G__Gui3_325_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY0",425,G__G__Gui3_325_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLeftButPressed",1608,G__G__Gui3_325_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRightButPressed",1723,G__G__Gui3_325_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMidButPressed",1495,G__G__Gui3_325_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX0",436,G__G__Gui3_325_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY0",437,G__G__Gui3_325_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - y0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLeftButPressed",1720,G__G__Gui3_325_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' press", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRightButPressed",1835,G__G__Gui3_325_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' press", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMidButPressed",1607,G__G__Gui3_325_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' press", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_325_0_23, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiTitleBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_325_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiTitleBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_325_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiTitleBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_325_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiTitleBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_325_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_325_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiTitleBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_325_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiTitleBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_325_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiTitleBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_325_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiTitleBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiTitleBar", 1354, G__G__Gui3_325_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiWinResizer(void) {
   /* TGMdiWinResizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer));
   G__memfunc_setup("MoveResizeIt",1222,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBox",695,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"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("TGMdiWinResizer",1479,G__G__Gui3_326_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiWinResizer), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - mdiwin "
"i - 'Int_t' 0 - pos U 'TGGC' - 10 - boxGC "
"i - 'Int_t' 0 - linew i - 'Int_t' 0 'kMdiDefaultResizeMode' mdioptions "
"i - 'Int_t' 0 '1' w i - 'Int_t' 0 '1' h "
"h - 'UInt_t' 0 'kOwnBackground' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetResizeMode",1315,G__G__Gui3_326_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinSize",1003,G__G__Gui3_326_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '50' w i - 'Int_t' 0 '20' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_326_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiWinResizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_326_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiWinResizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_326_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiWinResizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_326_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiWinResizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_326_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__Gui3_326_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiWinResizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_326_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiWinResizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_326_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiWinResizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_326_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiWinResizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiWinResizer", 1605, G__G__Gui3_326_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiVerticalWinResizer(void) {
   /* TGMdiVerticalWinResizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer));
   G__memfunc_setup("TGMdiVerticalWinResizer",2305,G__G__Gui3_327_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiVerticalWinResizer), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - mdiwin "
"i - 'Int_t' 0 - pos U 'TGGC' - 10 - boxGC "
"i - 'Int_t' 0 - linew i - 'Int_t' 0 'kMdiDefaultResizeMode' mdioptions "
"i - 'Int_t' 0 '4' w i - 'Int_t' 0 '5' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_327_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiVerticalWinResizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_327_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiVerticalWinResizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_327_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiVerticalWinResizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_327_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiVerticalWinResizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_327_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_327_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiVerticalWinResizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_327_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiVerticalWinResizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_327_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiVerticalWinResizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_327_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiVerticalWinResizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiVerticalWinResizer", 2431, G__G__Gui3_327_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiHorizontalWinResizer(void) {
   /* TGMdiHorizontalWinResizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer));
   G__memfunc_setup("TGMdiHorizontalWinResizer",2545,G__G__Gui3_328_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiHorizontalWinResizer), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - mdiwin "
"i - 'Int_t' 0 - pos U 'TGGC' - 10 - boxGC "
"i - 'Int_t' 0 - linew i - 'Int_t' 0 'kMdiDefaultResizeMode' mdioptions "
"i - 'Int_t' 0 '5' w i - 'Int_t' 0 '4' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_328_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiHorizontalWinResizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_328_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiHorizontalWinResizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_328_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiHorizontalWinResizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_328_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiHorizontalWinResizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_328_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_328_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiHorizontalWinResizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_328_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiHorizontalWinResizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_328_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiHorizontalWinResizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_328_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiHorizontalWinResizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiHorizontalWinResizer", 2671, G__G__Gui3_328_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMdiCornerWinResizer(void) {
   /* TGMdiCornerWinResizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer));
   G__memfunc_setup("TGMdiCornerWinResizer",2096,G__G__Gui3_329_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGMdiCornerWinResizer), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - mdiwin "
"i - 'Int_t' 0 - pos U 'TGGC' - 10 - boxGC "
"i - 'Int_t' 0 - linew i - 'Int_t' 0 'kMdiDefaultResizeMode' mdioptions "
"i - 'Int_t' 0 '20' w i - 'Int_t' 0 '20' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_329_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMdiCornerWinResizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_329_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiCornerWinResizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_329_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMdiCornerWinResizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_329_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMdiCornerWinResizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_329_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_329_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiCornerWinResizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_329_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiCornerWinResizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_329_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMdiCornerWinResizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_329_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMdiCornerWinResizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMdiCornerWinResizer", 2222, G__G__Gui3_329_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualDragManager(void) {
   /* TVirtualDragManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TVirtualDragManager",1908,G__G__Gui3_332_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDragType",1088,G__G__Gui3_332_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_EDragType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMoveWaiting",1318,G__G__Gui3_332_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDragging",991,G__G__Gui3_332_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDropping",1023,G__G__Gui3_332_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsPasting",914,G__G__Gui3_332_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTarget",903,G__G__Gui3_332_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSource",913,G__G__Gui3_332_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameUnder",1289,G__G__Gui3_332_0_10, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPasteFrame",1288,G__G__Gui3_332_0_11, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTarget",915,G__G__Gui3_332_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSource",925,G__G__Gui3_332_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPasteFrame",1300,G__G__Gui3_332_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartDrag",908,G__G__Gui3_332_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"U 'TGFrame' - 0 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EndDrag",661,G__G__Gui3_332_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Drop",405,G__G__Gui3_332_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cancel",582,G__G__Gui3_332_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleEvent",1102,G__G__Gui3_332_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleTimerEvent",1615,G__G__Gui3_332_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'Event_t' - 0 - - U 'TTimer' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreEvent",1126,G__G__Gui3_332_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditable",1094,G__G__Gui3_332_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStrartDragX",1398,G__G__Gui3_332_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStrartDragY",1399,G__G__Gui3_332_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEndDragX",1037,G__G__Gui3_332_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEndDragY",1038,G__G__Gui3_332_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Instance",821,G__G__Gui3_332_0_27, 85, G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualDragManager* (*)())(&TVirtualDragManager::Instance) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui3_332_0_28, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualDragManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_332_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualDragManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_332_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualDragManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_332_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualDragManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_332_0_32, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_332_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__Gui3_332_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__Gui3_332_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__Gui3_332_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualDragManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_332_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualDragManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_332_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualDragManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_332_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualDragManager::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TVirtualDragManager", 1908, G__G__Gui3_332_0_40, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager), -1, 0, 1, 1, 1, 0, "u 'TVirtualDragManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualDragManager", 2034, G__G__Gui3_332_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__Gui3_332_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager), -1, 1, 1, 1, 1, 0, "u 'TVirtualDragManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGuiBldAction(void) {
   /* TGuiBldAction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction));
   G__memfunc_setup("TGuiBldAction",1257,G__G__Gui3_334_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction), -1, 0, 4, 1, 1, 0, 
"C - - 10 '0' name C - - 10 '0' title "
"i - 'Int_t' 0 'kGuiBldCtor' type U 'TGLayoutHints' - 0 '0' hints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_334_0_2, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGuiBldAction::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_334_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiBldAction::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_334_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGuiBldAction::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_334_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGuiBldAction::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_334_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__Gui3_334_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiBldAction::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_334_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGuiBldAction::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_334_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiBldAction::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_334_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGuiBldAction::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGuiBldAction", 1257, G__G__Gui3_334_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction), -1, 0, 1, 1, 1, 0, "u 'TGuiBldAction' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGuiBldAction", 1383, G__G__Gui3_334_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGuiBuilder(void) {
   /* TGuiBuilder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder));
   G__memfunc_setup("TGuiBuilder",1088,G__G__Gui3_335_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAction",871,G__G__Gui3_335_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGuiBldAction' - 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddSection",990,G__G__Gui3_335_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteAction",1329,G__G__Gui3_335_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAction",906,G__G__Gui3_335_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGuiBldAction' - 0 - act", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAction",894,G__G__Gui3_335_0_6, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGuiBldAction), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsExecutable",1214,G__G__Gui3_335_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Gui3_335_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,G__G__Gui3_335_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Instance",821,G__G__Gui3_335_0_10, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGuiBuilder* (*)())(&TGuiBuilder::Instance) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui3_335_0_11, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGuiBuilder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_335_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiBuilder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_335_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGuiBuilder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_335_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGuiBuilder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_335_0_15, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_335_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui3_335_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui3_335_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__Gui3_335_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiBuilder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_335_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGuiBuilder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_335_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGuiBuilder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_335_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGuiBuilder::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGuiBuilder", 1088, G__G__Gui3_335_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder), -1, 0, 1, 1, 1, 0, "u 'TGuiBuilder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGuiBuilder", 1214, G__G__Gui3_335_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__Gui3_335_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder), -1, 1, 1, 1, 1, 0, "u 'TGuiBuilder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRedirectOutputGuard(void) {
   /* TGRedirectOutputGuard */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGRedirectOutputGuard));
   G__memfunc_setup("TGRedirectOutputGuard",2129,G__G__Gui3_336_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGRedirectOutputGuard), -1, 0, 3, 1, 1, 0, 
"U 'TGTextView' - 0 - tv C - - 10 '0' flog "
"C - - 10 '\"a\"' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Gui3_336_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", "Update window with file content", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_336_0_3, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRedirectOutputGuard::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_336_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRedirectOutputGuard::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_336_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRedirectOutputGuard::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_336_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRedirectOutputGuard::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_336_0_7, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_336_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__Gui3_336_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__Gui3_336_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__Gui3_336_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRedirectOutputGuard::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_336_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRedirectOutputGuard::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_336_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRedirectOutputGuard::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_336_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRedirectOutputGuard::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGRedirectOutputGuard", 2129, G__G__Gui3_336_0_15, (int) ('i'), 
G__get_linked_tagnum(&G__G__Gui3LN_TGRedirectOutputGuard), -1, 0, 1, 1, 1, 0, "u 'TGRedirectOutputGuard' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGRedirectOutputGuard", 2255, G__G__Gui3_336_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__Gui3_336_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGRedirectOutputGuard), -1, 1, 1, 1, 1, 0, "u 'TGRedirectOutputGuard' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPasswdDialog(void) {
   /* TGPasswdDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog));
   G__memfunc_setup("TGPasswdDialog",1373,G__G__Gui3_338_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog), -1, 0, 5, 1, 1, 0, 
"C - - 10 - prompt C - - 0 - pwdbuf "
"i - 'Int_t' 0 - pwdlenmax h - 'UInt_t' 0 '400' w "
"h - 'UInt_t' 0 '400' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReturnPressed",1366,G__G__Gui3_338_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,G__G__Gui3_338_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClose",681,G__G__Gui3_338_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_338_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPasswdDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_338_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPasswdDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_338_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPasswdDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_338_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPasswdDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_338_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_338_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__Gui3_338_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__Gui3_338_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__Gui3_338_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPasswdDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_338_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPasswdDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_338_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPasswdDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_338_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPasswdDialog::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGPasswdDialog", 1373, G__G__Gui3_338_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog), -1, 0, 1, 1, 1, 0, "u 'TGPasswdDialog' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGPasswdDialog", 1499, G__G__Gui3_338_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__Gui3_338_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGPasswdDialog), -1, 1, 1, 1, 1, 0, "u 'TGPasswdDialog' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextEditor(void) {
   /* TGTextEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor));
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGTextEditor",1191,G__G__Gui3_358_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor), -1, 0, 4, 1, 1, 0, 
"C - - 10 '0' filename U 'TGWindow' - 10 '0' p "
"h - 'UInt_t' 0 '900' w h - 'UInt_t' 0 '600' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEditor",1191,G__G__Gui3_358_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTextEditor), -1, 0, 4, 1, 1, 0, 
"U 'TMacro' - 0 - macro U 'TGWindow' - 10 '0' p "
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearText",908,G__G__Gui3_358_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadBuffer",986,G__G__Gui3_358_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - buf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadFile",768,G__G__Gui3_358_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 '0' fname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveFile",783,G__G__Gui3_358_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveFileAs",963,G__G__Gui3_358_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintText",946,G__G__Gui3_358_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Search",598,G__G__Gui3_358_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ret", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Goto",409,G__G__Gui3_358_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("About",507,G__G__Gui3_358_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataChanged",1060,G__G__Gui3_358_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataDropped",1096,G__G__Gui3_358_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - fname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSaved",687,G__G__Gui3_358_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompileMacro",1211,G__G__Gui3_358_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMacro",1221,G__G__Gui3_358_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InterruptMacro",1471,G__G__Gui3_358_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__Gui3_358_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGText' - 0 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddText",686,G__G__Gui3_358_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGText' - 0 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLine",657,G__G__Gui3_358_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLineFast",1055,G__G__Gui3_358_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui3_358_0_23, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGText), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteWindow",1227,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_358_0_29, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_358_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_358_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_358_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_358_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__Gui3_358_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_358_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_358_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_358_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextEditor", 1317, G__G__Gui3_358_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSpeedo(void) {
   /* TGSpeedo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawNeedle",987,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawText",819,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Translate",942,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"f - 'Float_t' 0 - val f - 'Float_t' 0 - angle "
"I - 'Int_t' 0 - x I - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGSpeedo",763,G__G__Gui3_375_0_5, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - - 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGSpeedo",763,G__G__Gui3_375_0_6, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSpeedo), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 - p f - 'Float_t' 0 - smin "
"f - 'Float_t' 0 - smax C - - 10 '\"\"' lbl1 "
"C - - 10 '\"\"' lbl2 C - - 10 '\"\"' dsp1 "
"C - - 10 '\"\"' dsp2 i - - 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui3LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPicture",1020,G__G__Gui3_375_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImage",771,G__G__Gui3_375_0_10, 85, G__get_linked_tagnum(&G__G__Gui3LN_TImage), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPeakVal",964,G__G__Gui3_375_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleMin",1068,G__G__Gui3_375_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleMax",1070,G__G__Gui3_375_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsThresholdActive",1733,G__G__Gui3_375_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,G__G__Gui3_375_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Glow",409,G__G__Gui3_375_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGSpeedo::EGlowColor' - 0 'kGreen' col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StepScale",900,G__G__Gui3_375_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleValue",1297,G__G__Gui3_375_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleValue",1297,G__G__Gui3_375_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - val i - 'Int_t' 0 - damping", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOdoValue",1099,G__G__Gui3_375_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDisplayText",1447,G__G__Gui3_375_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text1 C - - 10 '\"\"' text2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelText",1201,G__G__Gui3_375_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text1 C - - 10 '\"\"' text2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinMaxScale",1374,G__G__Gui3_375_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetThresholds",1356,G__G__Gui3_375_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 '0.0' th1 f - 'Float_t' 0 '0.0' th2 "
"f - 'Float_t' 0 '0.0' th3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetThresholdColors",1867,G__G__Gui3_375_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TGSpeedo::EGlowColor' - 0 - col1 i 'TGSpeedo::EGlowColor' - 0 - col2 "
"i 'TGSpeedo::EGlowColor' - 0 - col3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableThreshold",1524,G__G__Gui3_375_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableThreshold",1633,G__G__Gui3_375_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnablePeakMark",1363,G__G__Gui3_375_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisablePeakMark",1472,G__G__Gui3_375_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableMeanMark",1363,G__G__Gui3_375_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableMeanMark",1472,G__G__Gui3_375_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetPeakVal",1191,G__G__Gui3_375_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMeanValue",1194,G__G__Gui3_375_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - mean", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OdoClicked",977,G__G__Gui3_375_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("LedClicked",964,G__G__Gui3_375_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_375_0_36, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSpeedo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_375_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSpeedo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_375_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSpeedo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_375_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSpeedo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_375_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_375_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSpeedo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_375_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSpeedo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_375_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSpeedo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_375_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSpeedo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSpeedo", 889, G__G__Gui3_375_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDragWindow(void) {
   /* TGDragWindow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGDragWindow",1169,G__G__Gui3_377_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGDragWindow), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p k - 'Pixmap_t' 0 - pic "
"k - 'Pixmap_t' 0 - mask h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui3LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapWindow",918,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnmapWindow",1145,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RaiseWindow",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerWindow",1153,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapRaised",886,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInputId",989,G__G__Gui3_377_0_10, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasWindow",916,G__G__Gui3_377_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "k - 'Window_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_377_0_12, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDragWindow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_377_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDragWindow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_377_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDragWindow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_377_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDragWindow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_377_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__Gui3_377_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDragWindow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_377_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDragWindow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_377_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDragWindow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_377_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDragWindow::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDragWindow", 1295, G__G__Gui3_377_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTable(void) {
   /* TGTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTable));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"h - 'UInt_t' 0 - nrows h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandColumns",1345,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandRows",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - nrows", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRHdrHeight",1257,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCHdrWidth",1153,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shrink",623,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"h - 'UInt_t' 0 - nrows h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShrinkColumns",1360,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShrinkRows",1050,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - nrows", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateHeaders",1311,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i 'EHeaderType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInterface",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TVirtualTableInterface' - 0 - interface h - 'UInt_t' 0 '50' nrows "
"h - 'UInt_t' 0 '20' ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTable",1114,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"h - 'UInt_t' 0 - nrows h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateRangeFrame",1595,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGTable",643,G__G__Gui3_378_0_15, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTable), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '0' id "
"U 'TVirtualTableInterface' - 0 '0' interface h - 'UInt_t' 0 '50' nrows "
"h - 'UInt_t' 0 '20' ncolumns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRow",600,G__G__Gui3_378_0_16, 85, G__get_linked_tagnum(&G__G__Gui3LN_TObjArray), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - row", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumn",910,G__G__Gui3_378_0_17, 85, G__get_linked_tagnum(&G__G__Gui3LN_TObjArray), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - columns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCell",672,G__G__Gui3_378_0_18, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 2, 1, 1, 9, 
"h - 'UInt_t' 0 - i h - 'UInt_t' 0 - j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCell",672,G__G__Gui3_378_0_19, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - i h - 'UInt_t' 0 - j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindCell",769,G__G__Gui3_378_0_20, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 1, 1, 1, 9, "u 'TGString' - 0 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindCell",769,G__G__Gui3_378_0_21, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 1, 1, 1, 0, "u 'TGString' - 0 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Gui3_378_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateView",1022,G__G__Gui3_378_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNTableRows",1281,G__G__Gui3_378_0_24, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNDataRows",1171,G__G__Gui3_378_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNTableColumns",1591,G__G__Gui3_378_0_26, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNDataColumns",1481,G__G__Gui3_378_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNTableCells",1353,G__G__Gui3_378_0_28, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNDataCells",1243,G__G__Gui3_378_0_29, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentRange",1520,G__G__Gui3_378_0_30, 85, G__get_linked_tagnum(&G__G__Gui3LN_TTableRange), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInterface",1201,G__G__Gui3_378_0_31, 85, G__get_linked_tagnum(&G__G__Gui3LN_TVirtualTableInterface), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCanvas",892,G__G__Gui3_378_0_32, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGCanvas), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRHdrFrame",1147,G__G__Gui3_378_0_33, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCHdrFrame",1132,G__G__Gui3_378_0_34, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowHeader",1185,G__G__Gui3_378_0_35, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 10 - row", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowHeader",1185,G__G__Gui3_378_0_36, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - row", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnHeader",1495,G__G__Gui3_378_0_37, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 10 - column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnHeader",1495,G__G__Gui3_378_0_38, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableHeader",1361,G__G__Gui3_378_0_39, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowBackground",1624,G__G__Gui3_378_0_40, 107, -1, G__defined_typename("Pixel_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - row", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHeaderBackground",1897,G__G__Gui3_378_0_41, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOddRowBackground",1915,G__G__Gui3_378_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pixel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEvenRowBackground",2034,G__G__Gui3_378_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pixel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHeaderBackground",1909,G__G__Gui3_378_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pixel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultColors",1635,G__G__Gui3_378_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveTable",895,G__G__Gui3_378_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rows i - 'Int_t' 0 - columns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GotoTableRange",1390,G__G__Gui3_378_0_47, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - xtl i - 'Int_t' 0 - ytl "
"i - 'Int_t' 0 - xbr i - 'Int_t' 0 - ybr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Gui3_378_0_48, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - row h - 'UInt_t' 0 - column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollCHeaders",1390,G__G__Gui3_378_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - xpos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollRHeaders",1405,G__G__Gui3_378_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ypos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextChunk",920,G__G__Gui3_378_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreviousChunk",1366,G__G__Gui3_378_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UserRangeChange",1490,G__G__Gui3_378_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Goto",409,G__G__Gui3_378_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Gui3_378_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_378_0_56, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_378_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_378_0_58, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_378_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_378_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_378_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_378_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_378_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_378_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTable", 769, G__G__Gui3_378_0_68, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTableCell(void) {
   /* TGTableCell */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveDraw",805,(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("Resize",626,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGDimension' - 0 - newsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Highlight",920,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - resize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui3_380_0_9, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGTableCell::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui3_380_0_10, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGTableCell::GetDefaultGC) ), 0);
   G__memfunc_setup("TGTableCell",1027,G__G__Gui3_380_0_11, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 11, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGTable' - 0 '0' table "
"U 'TGString' - 0 '0' label h - 'UInt_t' 0 '0' row "
"h - 'UInt_t' 0 '0' column h - 'UInt_t' 0 '80' width "
"h - 'UInt_t' 0 '25' height k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option "
"g - 'Bool_t' 0 'kTRUE' resize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTableCell",1027,G__G__Gui3_380_0_12, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTableCell), -1, 0, 11, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGTable' - 0 - table "
"C - - 10 - label h - 'UInt_t' 0 '0' row "
"h - 'UInt_t' 0 '0' column h - 'UInt_t' 0 '80' width "
"h - 'UInt_t' 0 '25' height k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option "
"g - 'Bool_t' 0 'kTRUE' resize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabel",780,G__G__Gui3_380_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Gui3_380_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 0 - image", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextJustify",1471,G__G__Gui3_380_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tmode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui3_380_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'FontStruct_t' 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui3_380_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fontName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Gui3_380_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectRow",920,G__G__Gui3_380_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectColumn",1230,G__G__Gui3_380_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumn",910,G__G__Gui3_380_0_22, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRow",600,G__G__Gui3_380_0_23, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabel",768,G__G__Gui3_380_0_24, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetImage",771,G__G__Gui3_380_0_25, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGPicture), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidth",800,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHeight",889,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui3LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextJustify",1459,G__G__Gui3_380_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_380_0_30, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTableCell::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_380_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableCell::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_380_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTableCell::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_380_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTableCell::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_380_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_380_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableCell::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_380_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableCell::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_380_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableCell::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_380_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableCell::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTableCell", 1153, G__G__Gui3_380_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTableHeader(void) {
   /* TGTableHeader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTableHeader",1228,G__G__Gui3_382_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 10, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGTable' - 0 '0' table "
"U 'TGString' - 0 '0' label h - 'UInt_t' 0 '0' position "
"i 'EHeaderType' - 0 'kColumnHeader' type h - 'UInt_t' 0 '80' width "
"h - 'UInt_t' 0 '25' height k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTableHeader",1228,G__G__Gui3_382_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeader), -1, 0, 10, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGTable' - 0 - table "
"C - - 10 - label h - 'UInt_t' 0 - position "
"i 'EHeaderType' - 0 'kColumnHeader' type h - 'UInt_t' 0 '80' width "
"h - 'UInt_t' 0 '25' height k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWidth",812,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - width", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHeight",901,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabel",780,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultLabel",1489,G__G__Gui3_382_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,G__G__Gui3_382_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", "Resize width or height", (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGDimension' - 0 - newsize", "depending on type", (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Gui3_382_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kSortAscending' order", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePosition",1464,G__G__Gui3_382_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Gui3_382_0_13, 105, G__get_linked_tagnum(&G__G__Gui3LN_EHeaderType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_382_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTableHeader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_382_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableHeader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_382_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTableHeader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_382_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTableHeader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_382_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__Gui3_382_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableHeader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_382_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableHeader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_382_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableHeader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_382_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableHeader::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTableHeader", 1354, G__G__Gui3_382_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTableFrame(void) {
   /* TGTableFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableFrame));
   G__memfunc_setup("TGTableFrame",1134,G__G__Gui3_384_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTableFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - nrows "
"h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrame",779,G__G__Gui3_384_0_2, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanvas",904,G__G__Gui3_384_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGCanvas' - 0 - canvas", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMouseWheel",1610,G__G__Gui3_384_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRegion",1010,G__G__Gui3_384_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
"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("Class",502,G__G__Gui3_384_0_6, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTableFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_384_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_384_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTableFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_384_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTableFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_384_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_384_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_384_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_384_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_384_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTableFrame", 1260, G__G__Gui3_384_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTableHeaderFrame(void) {
   /* TGTableHeaderFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame));
   G__memfunc_setup("TGTableHeaderFrame",1719,G__G__Gui3_385_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGTableHeaderFrame), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGTable' - 0 '0' table "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h "
"i 'EHeaderType' - 0 'kColumnHeader' type h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRegion",1010,G__G__Gui3_385_0_2, 121, -1, -1, 0, 4, 1, 1, 0, 
"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("Class",502,G__G__Gui3_385_0_3, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTableHeaderFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_385_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableHeaderFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_385_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTableHeaderFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_385_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTableHeaderFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_385_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__Gui3_385_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableHeaderFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_385_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableHeaderFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_385_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableHeaderFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_385_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableHeaderFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTableHeaderFrame", 1845, G__G__Gui3_385_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTableRange(void) {
   /* TTableRange */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TTableRange));
   G__memfunc_setup("TTableRange",1065,G__G__Gui3_387_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TTableRange), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Gui3_387_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator==",998,G__G__Gui3_387_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TTableRange' - 1 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_387_0_4, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTableRange::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_387_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableRange::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_387_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTableRange::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_387_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTableRange::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui3_387_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui3_387_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui3_387_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui3_387_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_387_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableRange::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_387_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableRange::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_387_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableRange::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_387_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableRange::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTableRange", 1065, G__G__Gui3_387_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TTableRange), -1, 0, 1, 1, 1, 0, "u 'TTableRange' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTableRange", 1191, G__G__Gui3_387_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__Gui3_387_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TTableRange), -1, 1, 1, 1, 1, 0, "u 'TTableRange' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSimpleTableInterface(void) {
   /* TGSimpleTableInterface */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface));
   G__memfunc_setup("TGSimpleTableInterface",2174,G__G__Gui3_388_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface), -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 2 - data h - 'UInt_t' 0 '2' nrows "
"h - 'UInt_t' 0 '2' ncolumns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - row h - 'UInt_t' 0 - column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValueAsString",1608,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 1, 
"h - 'UInt_t' 0 - row h - 'UInt_t' 0 - column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowHeader",1185,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 1, "h - 'UInt_t' 0 - row", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnHeader",1495,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 1, "h - 'UInt_t' 0 - column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNRows",793,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNColumns",1103,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_388_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSimpleTableInterface::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_388_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSimpleTableInterface::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_388_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSimpleTableInterface::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_388_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSimpleTableInterface::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_388_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__Gui3_388_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSimpleTableInterface::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_388_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSimpleTableInterface::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_388_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSimpleTableInterface::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_388_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSimpleTableInterface::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGSimpleTableInterface", 2174, G__G__Gui3_388_0_20, (int) ('i'), 
G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface), -1, 0, 1, 1, 1, 0, "u 'TGSimpleTableInterface' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGSimpleTableInterface", 2300, G__G__Gui3_388_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui3_388_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTableInterface), -1, 1, 1, 1, 1, 0, "u 'TGSimpleTableInterface' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSimpleTable(void) {
   /* TGSimpleTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable));
   G__memfunc_setup("TGSimpleTable",1261,G__G__Gui3_389_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSimpleTable), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 0 - p i - 'Int_t' 0 - id "
"D - 'Double_t' 2 - data h - 'UInt_t' 0 - nrows "
"h - 'UInt_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_389_0_2, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSimpleTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_389_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSimpleTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_389_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSimpleTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_389_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSimpleTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_389_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__Gui3_389_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSimpleTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_389_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSimpleTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_389_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSimpleTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_389_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSimpleTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSimpleTable", 1387, G__G__Gui3_389_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGCommandPlugin(void) {
   /* TGCommandPlugin */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin));
   G__memfunc_setup("TGCommandPlugin",1481,G__G__Gui3_390_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGCommandPlugin), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckRemote",1098,G__G__Gui3_390_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleCommand",1291,G__G__Gui3_390_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_390_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGCommandPlugin::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_390_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCommandPlugin::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_390_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGCommandPlugin::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_390_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGCommandPlugin::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_390_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__Gui3_390_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCommandPlugin::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_390_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCommandPlugin::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_390_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCommandPlugin::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_390_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCommandPlugin::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGCommandPlugin", 1607, G__G__Gui3_390_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRootBrowser(void) {
   /* TRootBrowser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser));
   G__memfunc_setup("TRootBrowser",1244,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser), -1, 0, 1, 1, 4, 0, "u 'TRootBrowser' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser), -1, 1, 1, 1, 4, 0, "u 'TRootBrowser' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TRootBrowser",1244,G__G__Gui3_391_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser), -1, 0, 6, 1, 1, 0, 
"U 'TBrowser' - 0 '0' b C - - 10 '\"ROOT Browser\"' name "
"h - 'UInt_t' 0 '800' width h - 'UInt_t' 0 '500' height "
"C - 'Option_t' 10 '\"\"' opt g - 'Bool_t' 0 'kTRUE' initshow", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRootBrowser",1244,G__G__Gui3_391_0_4, 105, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser), -1, 0, 8, 1, 1, 0, 
"U 'TBrowser' - 0 - b C - - 10 - name "
"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 g - 'Bool_t' 0 'kTRUE' initshow", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPlugins",1142,G__G__Gui3_391_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateBrowser",1336,G__G__Gui3_391_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneBrowser",1237,G__G__Gui3_391_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseTab",781,G__G__Gui3_391_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTab",458,G__G__Gui3_391_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActFrame",1059,G__G__Gui3_391_0_11, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetToolbarFrame",1502,G__G__Gui3_391_0_12, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatusBar",1209,G__G__Gui3_391_0_13, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGStatusBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabLeft",962,G__G__Gui3_391_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabRight",1077,G__G__Gui3_391_0_15, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabBottom",1196,G__G__Gui3_391_0_16, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTab",567,G__G__Gui3_391_0_17, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGTab), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTab",579,G__G__Gui3_391_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'kRight' pos i - 'Int_t' 0 '-1' subpos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTabTitle",1093,G__G__Gui3_391_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - title i - 'Int_t' 0 'kRight' pos "
"i - 'Int_t' 0 '-1' subpos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMenu",993,G__G__Gui3_391_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecursiveReparent",1785,G__G__Gui3_391_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPopupMenu' - 0 - popup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveTab",901,G__G__Gui3_391_0_22, 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("SetActBrowser",1320,G__G__Gui3_391_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowserImp' - 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMenu",822,G__G__Gui3_391_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGCompositeFrame' - 0 - menu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartEmbedding",1421,G__G__Gui3_391_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'kRight' pos i - 'Int_t' 0 '-1' subpos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopEmbedding",1317,G__G__Gui3_391_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopEmbedding",1317,G__G__Gui3_391_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TGLayoutHints' - 0 - layout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwitchMenus",1146,G__G__Gui3_391_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGCompositeFrame' - 0 - from", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BrowseObj",909,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteDefaultAction",2038,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui3_391_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Checked",679,G__G__Gui3_391_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - check", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Gui3_391_0_33, 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, 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("Refresh",719,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("GetMainFrame",1168,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_TGMainFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecPlugin",1012,G__G__Gui3_391_0_39, 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 'kRight' pos "
"i - 'Int_t' 0 '-1' subpos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatusText",1365,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - txt i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowCloseTab",1198,G__G__Gui3_391_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCloseTabShown",1496,G__G__Gui3_391_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReallyDelete",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewBrowser",1038,G__G__Gui3_391_0_45, 85, G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp), -1, 0, 5, 3, 1, 0, 
"U 'TBrowser' - 0 '0' b C - - 10 '\"ROOT Browser\"' title "
"h - 'UInt_t' 0 '800' width h - 'UInt_t' 0 '500' height "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) G__func2void( (TBrowserImp* (*)(TBrowser*, const char*, UInt_t, UInt_t, Option_t*))(&TRootBrowser::NewBrowser) ), 0);
   G__memfunc_setup("NewBrowser",1038,G__G__Gui3_391_0_46, 85, G__get_linked_tagnum(&G__G__Gui3LN_TBrowserImp), -1, 0, 7, 3, 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*) G__func2void( (TBrowserImp* (*)(TBrowser*, const char*, Int_t, Int_t, UInt_t, UInt_t, Option_t*))(&TRootBrowser::NewBrowser) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui3_391_0_47, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRootBrowser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_391_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootBrowser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_391_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRootBrowser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_391_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRootBrowser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_391_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__Gui3_391_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootBrowser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_391_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootBrowser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_391_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRootBrowser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_391_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRootBrowser::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRootBrowser", 1370, G__G__Gui3_391_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFileBrowser(void) {
   /* TGFileBrowser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser));
   G__memfunc_setup("CreateBrowser",1336,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFileBrowser",1279,G__G__Gui3_394_0_2, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGFileBrowser), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TBrowser' - 0 '0' b "
"h - 'UInt_t' 0 '200' w h - 'UInt_t' 0 '400' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Gui3_394_0_3, 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, 1);
   G__memfunc_setup("BrowseObj",909,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("GetNewBrowser",1326,G__G__Gui3_394_0_9, 85, G__get_linked_tagnum(&G__G__Gui3LN_TRootBrowser), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNewBrowser",1338,G__G__Gui3_394_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRootBrowser' - 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFSDirectory",1367,G__G__Gui3_394_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - entry C - - 10 '0' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddKey",562,G__G__Gui3_394_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - itm U 'TObject' - 0 - obj "
"C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRemoteFile",1269,G__G__Gui3_394_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyFilter",1132,G__G__Gui3_394_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chdir",490,G__G__Gui3_394_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Checked",679,G__G__Gui3_394_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckRemote",1098,G__G__Gui3_394_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSorted",1103,G__G__Gui3_394_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 'kFALSE' but", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clicked",687,G__G__Gui3_394_0_19, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DirName",672,G__G__Gui3_394_0_20, 117, G__get_linked_tagnum(&G__G__Gui3LN_TString), -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FullPathName",1185,G__G__Gui3_394_0_21, 117, G__get_linked_tagnum(&G__G__Gui3LN_TString), -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui3_394_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XXExecuteDefaultAction",2214,G__G__Gui3_394_0_23, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FormatFileInfo",1397,G__G__Gui3_394_0_24, 67, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - fname n - 'Long64_t' 0 - size "
"l - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFilePictures",1519,G__G__Gui3_394_0_25, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGPicture' - 12 - pic i - 'Int_t' 0 - file_type "
"g - 'Bool_t' 0 - is_link C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjPicture",1303,G__G__Gui3_394_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 12 - pic U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GotoDir",696,G__G__Gui3_394_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PadModified",1078,G__G__Gui3_394_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Selected",809,G__G__Gui3_394_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleSort",1034,G__G__Gui3_394_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Gui3_394_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_394_0_32, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFileBrowser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_394_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileBrowser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_394_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFileBrowser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_394_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFileBrowser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_394_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui3_394_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileBrowser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_394_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileBrowser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_394_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileBrowser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_394_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileBrowser::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFileBrowser", 1405, G__G__Gui3_394_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBrowserPlugin(void) {
   /* TBrowserPlugin */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin));
   G__memfunc_setup("TBrowserPlugin",1447,G__G__Gui3_401_0_1, 105, G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' cmd "
"i - 'Int_t' 0 '1' tab i - 'Int_t' 0 '-1' sub", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTab",579,G__G__Gui3_401_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubTab",877,G__G__Gui3_401_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - sub", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCommand",1003,G__G__Gui3_401_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - cmd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_401_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBrowserPlugin::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_401_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowserPlugin::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_401_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBrowserPlugin::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_401_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBrowserPlugin::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_401_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__Gui3_401_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowserPlugin::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_401_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBrowserPlugin::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_401_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBrowserPlugin::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_401_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBrowserPlugin::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TBrowserPlugin", 1447, G__G__Gui3_401_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin), -1, 0, 1, 1, 1, 0, "u 'TBrowserPlugin' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TBrowserPlugin", 1573, G__G__Gui3_401_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__Gui3_401_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Gui3LN_TBrowserPlugin), -1, 1, 1, 1, 1, 0, "u 'TBrowserPlugin' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRectMap(void) {
   /* TGRectMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap));
   G__memfunc_setup("TGRectMap",839,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap), -1, 0, 1, 1, 4, 0, "u 'TGRectMap' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap), -1, 1, 1, 1, 4, 0, "u 'TGRectMap' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGRectMap",839,G__G__Gui3_409_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGRectMap), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - rx i - 'Int_t' 0 - ry "
"h - 'UInt_t' 0 - rw h - 'UInt_t' 0 - rh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Gui3_409_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_409_0_5, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRectMap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_409_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRectMap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_409_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRectMap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_409_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRectMap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_409_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__Gui3_409_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRectMap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_409_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRectMap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_409_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRectMap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_409_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRectMap::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGRectMap", 965, G__G__Gui3_409_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSplitTool(void) {
   /* TGSplitTool */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool));
   G__memfunc_setup("TGSplitTool",1093,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool), -1, 0, 1, 1, 4, 0, "u 'TGSplitTool' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool), -1, 1, 1, 1, 4, 0, "u 'TGSplitTool' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGSplitTool",1093,G__G__Gui3_410_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGFrame' - 10 '0' f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRectangle",1182,G__G__Gui3_410_0_4, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TGFrame' - 0 - frm i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y i - 'Int_t' 0 - w "
"i - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Gui3_410_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hide",378,G__G__Gui3_410_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Gui3_410_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__G__Gui3_410_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui3_410_0_13, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSplitTool::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_410_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitTool::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_410_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSplitTool::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_410_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSplitTool::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_410_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__Gui3_410_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitTool::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_410_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitTool::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_410_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitTool::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_410_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitTool::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSplitTool", 1219, G__G__Gui3_410_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSplitFrame(void) {
   /* TGSplitFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame));
   G__memfunc_setup("TGSplitFrame",1170,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame), -1, 0, 1, 1, 4, 0, "u 'TGSplitFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame), -1, 1, 1, 1, 4, 0, "u 'TGSplitFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGSplitFrame",1170,G__G__Gui3_411_0_3, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFrame",756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cleanup",712,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleConfigureNotify",2151,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HSplit",596,G__G__Gui3_411_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("VSplit",610,G__G__Gui3_411_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '0' w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFrame",1113,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFirst",808,G__G__Gui3_411_0_10, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrame",779,G__G__Gui3_411_0_11, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecond",892,G__G__Gui3_411_0_12, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSplitter",1143,G__G__Gui3_411_0_13, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitter), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSplitTool",1226,G__G__Gui3_411_0_14, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitTool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopFrame",1086,G__G__Gui3_411_0_15, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGSplitFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUndocked",1101,G__G__Gui3_411_0_16, 85, G__get_linked_tagnum(&G__G__Gui3LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHRatio",871,G__G__Gui3_411_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWRatio",886,G__G__Gui3_411_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MapToSPlitTool",1387,G__G__Gui3_411_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGSplitFrame' - 0 - top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnSplitterClicked",1731,G__G__Gui3_411_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHRatio",883,G__G__Gui3_411_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWRatio",898,G__G__Gui3_411_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitHorizontal",1590,G__G__Gui3_411_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"top\"' side", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitVertical",1350,G__G__Gui3_411_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"left\"' side", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnSplit",719,G__G__Gui3_411_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - which", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,G__G__Gui3_411_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CloseAndCollapse",1596,G__G__Gui3_411_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ExtractFrame",1222,G__G__Gui3_411_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SwallowBack",1114,G__G__Gui3_411_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SwitchToMain",1210,G__G__Gui3_411_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SplitHor",821,G__G__Gui3_411_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SplitVer",825,G__G__Gui3_411_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Docked",586,G__G__Gui3_411_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - frame", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Undocked",813,G__G__Gui3_411_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - frame", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("SwitchFrames",1232,G__G__Gui3_411_0_35, 121, -1, -1, 0, 3, 3, 1, 0, 
"U 'TGFrame' - 0 - frame U 'TGCompositeFrame' - 0 - dest "
"U 'TGFrame' - 0 - prev", (char*)NULL, (void*) G__func2void( (void (*)(TGFrame*, TGCompositeFrame*, TGFrame*))(&TGSplitFrame::SwitchFrames) ), 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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_411_0_37, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSplitFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_411_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_411_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSplitFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_411_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSplitFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_411_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__Gui3_411_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_411_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_411_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_411_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSplitFrame", 1296, G__G__Gui3_411_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGShapedFrame(void) {
   /* TGShapedFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame));
   G__memfunc_setup("TGShapedFrame",1243,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame), -1, 0, 1, 1, 4, 0, "u 'TGShapedFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame), -1, 1, 1, 1, 4, 0, "u 'TGShapedFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGShapedFrame",1243,G__G__Gui3_412_0_4, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGShapedFrame), -1, 0, 5, 1, 1, 0, 
"C - - 10 '0' fname U 'TGWindow' - 10 '0' p "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h "
"h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui3_412_0_5, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImage",771,G__G__Gui3_412_0_6, 117, G__get_linked_tagnum(&G__G__Gui3LN_TImage), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_412_0_8, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGShapedFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_412_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShapedFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_412_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGShapedFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_412_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGShapedFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_412_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__Gui3_412_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShapedFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_412_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGShapedFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_412_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShapedFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_412_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGShapedFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGShapedFrame", 1369, G__G__Gui3_412_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGEventHandler(void) {
   /* TGEventHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler));
   G__memfunc_setup("TGEventHandler",1371,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler), -1, 0, 1, 1, 4, 0, "u 'TGEventHandler' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler), -1, 1, 1, 1, 4, 0, "u 'TGEventHandler' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 0, "", "used to set gTQSender", (void*) NULL, 1);
   G__memfunc_setup("TGEventHandler",1371,G__G__Gui3_413_0_4, 105, G__get_linked_tagnum(&G__G__Gui3LN_TGEventHandler), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'TGWindow' - 0 - w "
"U 'TObject' - 0 - obj C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Activate",817,G__G__Gui3_413_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeActivate",986,G__G__Gui3_413_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__Gui3_413_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleEvent",1102,G__G__Gui3_413_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleConfigureNotify",2151,G__G__Gui3_413_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,G__G__Gui3_413_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDoubleClick",1677,G__G__Gui3_413_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,G__G__Gui3_413_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,G__G__Gui3_413_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,G__G__Gui3_413_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleFocusChange",1682,G__G__Gui3_413_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelection",1522,G__G__Gui3_413_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionRequest",2267,G__G__Gui3_413_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionClear",2009,G__G__Gui3_413_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleColormapChange",1999,G__G__Gui3_413_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessedEvent",1450,G__G__Gui3_413_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("SendMessage",1103,G__G__Gui3_413_0_21, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - w l - 'Long_t' 0 - msg "
"l - 'Long_t' 0 - parm1 l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,G__G__Gui3_413_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - - l - 'Long_t' 0 - - "
"l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Repaint",723,G__G__Gui3_413_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui3_413_0_24, 85, G__get_linked_tagnum(&G__G__Gui3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGEventHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui3_413_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGEventHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui3_413_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGEventHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui3_413_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGEventHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui3LN_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__Gui3_413_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__Gui3_413_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGEventHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui3_413_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGEventHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui3_413_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGEventHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui3_413_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGEventHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGEventHandler", 1497, G__G__Gui3_413_0_36, (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__Gui3() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDNDFlags),-1,-1,1,"kIsDNDSource=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDNDFlags),-1,-1,1,"kIsDNDTarget=2",0,(char*)NULL);
}

static void G__cpp_setup_global5() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizingModes),-1,-1,1,"kMdiOpaque=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizingModes),-1,-1,1,"kMdiNonOpaque=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizingModes),-1,-1,1,"kMdiDefaultResizeMode=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiClose=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiRestore=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiMove=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiSize=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiMinimize=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiMaximize=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiHelp=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiMenu=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiHints),-1,-1,1,"kMdiDefaultHints=748",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiArrangementModes),-1,-1,1,"kMdiTileHorizontal=1",0,(char*)NULL);
}

static void G__cpp_setup_global6() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiArrangementModes),-1,-1,1,"kMdiTileVertical=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiArrangementModes),-1,-1,1,"kMdiCascade=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiGeometryMask),-1,-1,1,"kMdiClientGeometry=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiGeometryMask),-1,-1,1,"kMdiDecorGeometry=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiGeometryMask),-1,-1,1,"kMdiIconGeometry=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizerPlacement),-1,-1,1,"kMdiResizerTop=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizerPlacement),-1,-1,1,"kMdiResizerBottom=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizerPlacement),-1,-1,1,"kMdiResizerLeft=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EMdiResizerPlacement),-1,-1,1,"kMdiResizerRight=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,1,"kDragNone=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,1,"kDragMove=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,1,"kDragCopy=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,1,"kDragLink=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,1,"kDragLasso=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EDragType),-1,-1,1,"kDragResize=5",0,(char*)NULL);
   G__memvar_setup((void*)(&gDragManager),85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TVirtualDragManager),-1,-1,1,"gDragManager=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EGuiBldAction),-1,-1,1,"kGuiBldNone=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EGuiBldAction),-1,-1,1,"kGuiBldCtor=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EGuiBldAction),-1,-1,1,"kGuiBldProj=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EGuiBldAction),-1,-1,1,"kGuiBldMacro=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui3LN_EGuiBldAction),-1,-1,1,"kGuiBldFunc=4",0,(char*)NULL);
   G__memvar_setup((void*)(&gGuiBuilder),85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGuiBuilder),-1,-1,1,"gGuiBuilder=",0,(char*)NULL);
   G__memvar_setup((void*)(&gDNDManager),85,0,0,G__get_linked_tagnum(&G__G__Gui3LN_TGDNDManager),-1,-1,1,"gDNDManager=",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Gui3() {
  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();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Gui3() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Gui3LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TMethod = { "TMethod" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRegexp = { "TRegexp" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TApplicationImp = { "TApplicationImp" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TCanvasImp = { "TCanvasImp" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TBrowserImp = { "TBrowserImp" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TContextMenuImp = { "TContextMenuImp" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TContextMenu = { "TContextMenu" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TControlBarImp = { "TControlBarImp" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TControlBar = { "TControlBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGuiFactory = { "TGuiFactory" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootGuiFactory = { "TRootGuiFactory" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGClient = { "TGClient" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootApplication = { "TRootApplication" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__Gui3LN_Rectangle_t = { "Rectangle_t" , 115 , -1 };
G__linked_taginfo G__G__Gui3LN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGPicture = { "TGPicture" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGGC = { "TGGC" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFont = { "TGFont" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGDimension = { "TGDimension" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGPosition = { "TGPosition" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGRectangle = { "TGRectangle" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGString = { "TGString" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGHotString = { "TGHotString" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TDNDData = { "TDNDData" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_EDNDFlags = { "EDNDFlags" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGCanvas = { "TGCanvas" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGStatusBar = { "TGStatusBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootContainer = { "TRootContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGToolBar = { "TGToolBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGHorizontal3DLine = { "TGHorizontal3DLine" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGVertical3DLine = { "TGVertical3DLine" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TVirtualPadEditor = { "TVirtualPadEditor" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGDockableFrame = { "TGDockableFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGDNDManager = { "TGDNDManager" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGToolTip = { "TGToolTip" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootCanvas = { "TRootCanvas" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFSComboBox = { "TGFSComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGListView = { "TGListView" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootIconBox = { "TRootIconBox" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGListTree = { "TGListTree" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFileContainer = { "TGFileContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTextEdit = { "TGTextEdit" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootBrowserLite = { "TRootBrowserLite" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TFunction = { "TFunction" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGWidget = { "TGWidget" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMenuEntry = { "TGMenuEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootDialog = { "TRootDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootContextMenu = { "TRootContextMenu" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootControlBar = { "TRootControlBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTextView = { "TGTextView" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootHelpDialog = { "TRootHelpDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootEmbeddedContainer = { "TRootEmbeddedContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootEmbeddedCanvas = { "TRootEmbeddedCanvas" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTextBuffer = { "TGTextBuffer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTab = { "TGTab" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TColorWheel = { "TColorWheel" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGColorPalette = { "TGColorPalette" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGColorPick = { "TGColorPick" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGColorDialog = { "TGColorDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGColorFrame = { "TGColorFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TG16ColorSelector = { "TG16ColorSelector" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGColorPopup = { "TGColorPopup" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGColorSelect = { "TGColorSelect" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGListBox = { "TGListBox" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFontDialog = { "TGFontDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFontDialogcLcLFontProp_t = { "TGFontDialog::FontProp_t" , 115 , -1 };
G__linked_taginfo G__G__Gui3LN_TGDockButton = { "TGDockButton" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGDockHideButton = { "TGDockHideButton" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGUndockedFrame = { "TGUndockedFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_EMdiResizingModes = { "EMdiResizingModes" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_EMdiHints = { "EMdiHints" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_EMdiArrangementModes = { "EMdiArrangementModes" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_EMdiGeometryMask = { "EMdiGeometryMask" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiMenuBar = { "TGMdiMenuBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiContainer = { "TGMdiContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiDecorFrame = { "TGMdiDecorFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiFrame = { "TGMdiFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiFrameList = { "TGMdiFrameList" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiMainFrame = { "TGMdiMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiGeometry = { "TGMdiGeometry" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiMainFramecLcLdA = { "TGMdiMainFrame::$" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiTitleIcon = { "TGMdiTitleIcon" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiButtons = { "TGMdiButtons" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TImage = { "TImage" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGIcon = { "TGIcon" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiFramecLcLdA = { "TGMdiFrame::$" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_EMdiResizerPlacement = { "EMdiResizerPlacement" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiTitleBar = { "TGMdiTitleBar" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiWinResizer = { "TGMdiWinResizer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiVerticalWinResizer = { "TGMdiVerticalWinResizer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiHorizontalWinResizer = { "TGMdiHorizontalWinResizer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiCornerWinResizer = { "TGMdiCornerWinResizer" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGMdiDecorFramecLcLdA = { "TGMdiDecorFrame::$" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_EDragType = { "EDragType" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TVirtualDragManager = { "TVirtualDragManager" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_EGuiBldAction = { "EGuiBldAction" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGuiBldAction = { "TGuiBldAction" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGuiBuilder = { "TGuiBuilder" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGRedirectOutputGuard = { "TGRedirectOutputGuard" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGPasswdDialog = { "TGPasswdDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGText = { "TGText" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TMacro = { "TMacro" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTextEditor = { "TGTextEditor" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSpeedo = { "TGSpeedo" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSpeedocLcLEGlowColor = { "TGSpeedo::EGlowColor" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGDragWindow = { "TGDragWindow" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTable = { "TGTable" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTableCell = { "TGTableCell" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_EHeaderType = { "EHeaderType" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTableHeader = { "TGTableHeader" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TVirtualTableInterface = { "TVirtualTableInterface" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTableFrame = { "TGTableFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGTableHeaderFrame = { "TGTableHeaderFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TTableRange = { "TTableRange" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSimpleTableInterface = { "TGSimpleTableInterface" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSimpleTable = { "TGSimpleTable" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGCommandPlugin = { "TGCommandPlugin" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootBrowser = { "TRootBrowser" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TSystemDirectory = { "TSystemDirectory" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TSystemFile = { "TSystemFile" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGFileBrowser = { "TGFileBrowser" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgR = { "list<TGListTreeItem*,allocator<TGListTreeItem*> >" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLiterator = { "list<TGListTreeItem*,allocator<TGListTreeItem*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLreverse_iterator = { "list<TGListTreeItem*,allocator<TGListTreeItem*> >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGVSplitter = { "TGVSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGHSplitter = { "TGHSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TBrowserPlugin = { "TBrowserPlugin" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TRootBrowsercLcLEInsertPosition = { "TRootBrowser::EInsertPosition" , 101 , -1 };
G__linked_taginfo G__G__Gui3LN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSplitter = { "TGSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGRectMap = { "TGRectMap" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSplitTool = { "TGSplitTool" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGSplitFrame = { "TGSplitFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGShapedFrame = { "TGShapedFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui3LN_TGEventHandler = { "TGEventHandler" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Gui3() {
  G__G__Gui3LN_TClass.tagnum = -1 ;
  G__G__Gui3LN_TBuffer.tagnum = -1 ;
  G__G__Gui3LN_TMemberInspector.tagnum = -1 ;
  G__G__Gui3LN_TObject.tagnum = -1 ;
  G__G__Gui3LN_TNamed.tagnum = -1 ;
  G__G__Gui3LN_TString.tagnum = -1 ;
  G__G__Gui3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Gui3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Gui3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui3LN_TList.tagnum = -1 ;
  G__G__Gui3LN_TBrowser.tagnum = -1 ;
  G__G__Gui3LN_TObjArray.tagnum = -1 ;
  G__G__Gui3LN_TMethod.tagnum = -1 ;
  G__G__Gui3LN_TTimer.tagnum = -1 ;
  G__G__Gui3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Gui3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui3LN_TRegexp.tagnum = -1 ;
  G__G__Gui3LN_TApplicationImp.tagnum = -1 ;
  G__G__Gui3LN_TCanvasImp.tagnum = -1 ;
  G__G__Gui3LN_TCanvas.tagnum = -1 ;
  G__G__Gui3LN_TBrowserImp.tagnum = -1 ;
  G__G__Gui3LN_TContextMenuImp.tagnum = -1 ;
  G__G__Gui3LN_TContextMenu.tagnum = -1 ;
  G__G__Gui3LN_TControlBarImp.tagnum = -1 ;
  G__G__Gui3LN_TControlBar.tagnum = -1 ;
  G__G__Gui3LN_TGuiFactory.tagnum = -1 ;
  G__G__Gui3LN_TRootGuiFactory.tagnum = -1 ;
  G__G__Gui3LN_TGClient.tagnum = -1 ;
  G__G__Gui3LN_TRootApplication.tagnum = -1 ;
  G__G__Gui3LN_Event_t.tagnum = -1 ;
  G__G__Gui3LN_Rectangle_t.tagnum = -1 ;
  G__G__Gui3LN_TGObject.tagnum = -1 ;
  G__G__Gui3LN_TQObject.tagnum = -1 ;
  G__G__Gui3LN_TGWindow.tagnum = -1 ;
  G__G__Gui3LN_TGPicture.tagnum = -1 ;
  G__G__Gui3LN_TGGC.tagnum = -1 ;
  G__G__Gui3LN_TGFont.tagnum = -1 ;
  G__G__Gui3LN_TGDimension.tagnum = -1 ;
  G__G__Gui3LN_TGPosition.tagnum = -1 ;
  G__G__Gui3LN_TGRectangle.tagnum = -1 ;
  G__G__Gui3LN_TGFrame.tagnum = -1 ;
  G__G__Gui3LN_TGCompositeFrame.tagnum = -1 ;
  G__G__Gui3LN_TGLayoutHints.tagnum = -1 ;
  G__G__Gui3LN_TGString.tagnum = -1 ;
  G__G__Gui3LN_TGHotString.tagnum = -1 ;
  G__G__Gui3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Gui3LN_TGTextButton.tagnum = -1 ;
  G__G__Gui3LN_TDNDData.tagnum = -1 ;
  G__G__Gui3LN_EDNDFlags.tagnum = -1 ;
  G__G__Gui3LN_TGVerticalFrame.tagnum = -1 ;
  G__G__Gui3LN_TGHorizontalFrame.tagnum = -1 ;
  G__G__Gui3LN_TGMainFrame.tagnum = -1 ;
  G__G__Gui3LN_TGTransientFrame.tagnum = -1 ;
  G__G__Gui3LN_TGCanvas.tagnum = -1 ;
  G__G__Gui3LN_TGMenuBar.tagnum = -1 ;
  G__G__Gui3LN_TGPopupMenu.tagnum = -1 ;
  G__G__Gui3LN_TGStatusBar.tagnum = -1 ;
  G__G__Gui3LN_TRootContainer.tagnum = -1 ;
  G__G__Gui3LN_TGToolBar.tagnum = -1 ;
  G__G__Gui3LN_TGHorizontal3DLine.tagnum = -1 ;
  G__G__Gui3LN_TGVertical3DLine.tagnum = -1 ;
  G__G__Gui3LN_TVirtualPadEditor.tagnum = -1 ;
  G__G__Gui3LN_TGDockableFrame.tagnum = -1 ;
  G__G__Gui3LN_TGDNDManager.tagnum = -1 ;
  G__G__Gui3LN_TGToolTip.tagnum = -1 ;
  G__G__Gui3LN_TRootCanvas.tagnum = -1 ;
  G__G__Gui3LN_TGButton.tagnum = -1 ;
  G__G__Gui3LN_TGFSComboBox.tagnum = -1 ;
  G__G__Gui3LN_TGLabel.tagnum = -1 ;
  G__G__Gui3LN_TGListView.tagnum = -1 ;
  G__G__Gui3LN_TRootIconBox.tagnum = -1 ;
  G__G__Gui3LN_TGListTree.tagnum = -1 ;
  G__G__Gui3LN_TGListTreeItem.tagnum = -1 ;
  G__G__Gui3LN_TGFileContainer.tagnum = -1 ;
  G__G__Gui3LN_TGComboBox.tagnum = -1 ;
  G__G__Gui3LN_TGTextEdit.tagnum = -1 ;
  G__G__Gui3LN_TRootBrowserLite.tagnum = -1 ;
  G__G__Gui3LN_TFunction.tagnum = -1 ;
  G__G__Gui3LN_TGWidget.tagnum = -1 ;
  G__G__Gui3LN_TGMenuEntry.tagnum = -1 ;
  G__G__Gui3LN_TRootDialog.tagnum = -1 ;
  G__G__Gui3LN_TRootContextMenu.tagnum = -1 ;
  G__G__Gui3LN_TRootControlBar.tagnum = -1 ;
  G__G__Gui3LN_TGTextView.tagnum = -1 ;
  G__G__Gui3LN_TRootHelpDialog.tagnum = -1 ;
  G__G__Gui3LN_TRootEmbeddedContainer.tagnum = -1 ;
  G__G__Gui3LN_TRootEmbeddedCanvas.tagnum = -1 ;
  G__G__Gui3LN_TGTextEntry.tagnum = -1 ;
  G__G__Gui3LN_TGTextBuffer.tagnum = -1 ;
  G__G__Gui3LN_TGTab.tagnum = -1 ;
  G__G__Gui3LN_TColorWheel.tagnum = -1 ;
  G__G__Gui3LN_TGColorPalette.tagnum = -1 ;
  G__G__Gui3LN_TGColorPick.tagnum = -1 ;
  G__G__Gui3LN_TGColorDialog.tagnum = -1 ;
  G__G__Gui3LN_TGPictureButton.tagnum = -1 ;
  G__G__Gui3LN_TGCheckButton.tagnum = -1 ;
  G__G__Gui3LN_TGColorFrame.tagnum = -1 ;
  G__G__Gui3LN_TG16ColorSelector.tagnum = -1 ;
  G__G__Gui3LN_TGColorPopup.tagnum = -1 ;
  G__G__Gui3LN_TGColorSelect.tagnum = -1 ;
  G__G__Gui3LN_TGListBox.tagnum = -1 ;
  G__G__Gui3LN_TGFontDialog.tagnum = -1 ;
  G__G__Gui3LN_TGFontDialogcLcLFontProp_t.tagnum = -1 ;
  G__G__Gui3LN_TGDockButton.tagnum = -1 ;
  G__G__Gui3LN_TGDockHideButton.tagnum = -1 ;
  G__G__Gui3LN_TGUndockedFrame.tagnum = -1 ;
  G__G__Gui3LN_EMdiResizingModes.tagnum = -1 ;
  G__G__Gui3LN_EMdiHints.tagnum = -1 ;
  G__G__Gui3LN_EMdiArrangementModes.tagnum = -1 ;
  G__G__Gui3LN_EMdiGeometryMask.tagnum = -1 ;
  G__G__Gui3LN_TGMdiMenuBar.tagnum = -1 ;
  G__G__Gui3LN_TGMdiContainer.tagnum = -1 ;
  G__G__Gui3LN_TGMdiDecorFrame.tagnum = -1 ;
  G__G__Gui3LN_TGMdiFrame.tagnum = -1 ;
  G__G__Gui3LN_TGMdiFrameList.tagnum = -1 ;
  G__G__Gui3LN_TGMdiMainFrame.tagnum = -1 ;
  G__G__Gui3LN_TGMdiGeometry.tagnum = -1 ;
  G__G__Gui3LN_TGMdiMainFramecLcLdA.tagnum = -1 ;
  G__G__Gui3LN_TGMdiTitleIcon.tagnum = -1 ;
  G__G__Gui3LN_TGMdiButtons.tagnum = -1 ;
  G__G__Gui3LN_TImage.tagnum = -1 ;
  G__G__Gui3LN_TGIcon.tagnum = -1 ;
  G__G__Gui3LN_TGMdiFramecLcLdA.tagnum = -1 ;
  G__G__Gui3LN_EMdiResizerPlacement.tagnum = -1 ;
  G__G__Gui3LN_TGMdiTitleBar.tagnum = -1 ;
  G__G__Gui3LN_TGMdiWinResizer.tagnum = -1 ;
  G__G__Gui3LN_TGMdiVerticalWinResizer.tagnum = -1 ;
  G__G__Gui3LN_TGMdiHorizontalWinResizer.tagnum = -1 ;
  G__G__Gui3LN_TGMdiCornerWinResizer.tagnum = -1 ;
  G__G__Gui3LN_TGMdiDecorFramecLcLdA.tagnum = -1 ;
  G__G__Gui3LN_EDragType.tagnum = -1 ;
  G__G__Gui3LN_TVirtualDragManager.tagnum = -1 ;
  G__G__Gui3LN_EGuiBldAction.tagnum = -1 ;
  G__G__Gui3LN_TGuiBldAction.tagnum = -1 ;
  G__G__Gui3LN_TGuiBuilder.tagnum = -1 ;
  G__G__Gui3LN_TGRedirectOutputGuard.tagnum = -1 ;
  G__G__Gui3LN_TGPasswdDialog.tagnum = -1 ;
  G__G__Gui3LN_TGText.tagnum = -1 ;
  G__G__Gui3LN_TMacro.tagnum = -1 ;
  G__G__Gui3LN_TGTextEditor.tagnum = -1 ;
  G__G__Gui3LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__Gui3LN_TGSpeedo.tagnum = -1 ;
  G__G__Gui3LN_TGSpeedocLcLEGlowColor.tagnum = -1 ;
  G__G__Gui3LN_TGDragWindow.tagnum = -1 ;
  G__G__Gui3LN_TGTable.tagnum = -1 ;
  G__G__Gui3LN_TGTableCell.tagnum = -1 ;
  G__G__Gui3LN_EHeaderType.tagnum = -1 ;
  G__G__Gui3LN_TGTableHeader.tagnum = -1 ;
  G__G__Gui3LN_TVirtualTableInterface.tagnum = -1 ;
  G__G__Gui3LN_TGTableFrame.tagnum = -1 ;
  G__G__Gui3LN_TGTableHeaderFrame.tagnum = -1 ;
  G__G__Gui3LN_TTableRange.tagnum = -1 ;
  G__G__Gui3LN_TGSimpleTableInterface.tagnum = -1 ;
  G__G__Gui3LN_TGSimpleTable.tagnum = -1 ;
  G__G__Gui3LN_TGCommandPlugin.tagnum = -1 ;
  G__G__Gui3LN_TRootBrowser.tagnum = -1 ;
  G__G__Gui3LN_TSystemDirectory.tagnum = -1 ;
  G__G__Gui3LN_TSystemFile.tagnum = -1 ;
  G__G__Gui3LN_TGFileBrowser.tagnum = -1 ;
  G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgR.tagnum = -1 ;
  G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__G__Gui3LN_TGVSplitter.tagnum = -1 ;
  G__G__Gui3LN_TGHSplitter.tagnum = -1 ;
  G__G__Gui3LN_TBrowserPlugin.tagnum = -1 ;
  G__G__Gui3LN_TRootBrowsercLcLEInsertPosition.tagnum = -1 ;
  G__G__Gui3LN_TMap.tagnum = -1 ;
  G__G__Gui3LN_TGSplitter.tagnum = -1 ;
  G__G__Gui3LN_TGRectMap.tagnum = -1 ;
  G__G__Gui3LN_TGSplitTool.tagnum = -1 ;
  G__G__Gui3LN_TGSplitFrame.tagnum = -1 ;
  G__G__Gui3LN_TGShapedFrame.tagnum = -1 ;
  G__G__Gui3LN_TGEventHandler.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Gui3() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TString);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TMethod);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TTimer);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRegexp);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TApplicationImp);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TCanvasImp);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TCanvas);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TBrowserImp);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TContextMenuImp);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TContextMenu);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TControlBarImp);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TControlBar);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGuiFactory);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootGuiFactory),sizeof(TRootGuiFactory),-1,62720,"Factory for ROOT GUI components",G__setup_memvarTRootGuiFactory,G__setup_memfuncTRootGuiFactory);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGClient);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootApplication),sizeof(TRootApplication),-1,34048,"ROOT native GUI application environment",G__setup_memvarTRootApplication,G__setup_memfuncTRootApplication);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_Rectangle_t);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGWindow);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGPicture);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGGC);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFont);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGDimension);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGPosition);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGRectangle);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGString);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGHotString);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTextButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TDNDData),sizeof(TDNDData),-1,32512,"Drag and drop specific data",G__setup_memvarTDNDData,G__setup_memfuncTDNDData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EDNDFlags),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGVerticalFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGHorizontalFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTransientFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGCanvas);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMenuBar);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGPopupMenu);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGStatusBar);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootContainer);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGToolBar);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGHorizontal3DLine);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGVertical3DLine);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TVirtualPadEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGDockableFrame),sizeof(TGDockableFrame),-1,65280,"Dockable widget",G__setup_memvarTGDockableFrame,G__setup_memfuncTGDockableFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGDNDManager),sizeof(TGDNDManager),-1,65024,"The main Drag and Drop Manager",G__setup_memvarTGDNDManager,G__setup_memfuncTGDNDManager);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGToolTip);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootCanvas),sizeof(TRootCanvas),-1,65280,"ROOT native GUI version of main window with menubar and drawing area",G__setup_memvarTRootCanvas,G__setup_memfuncTRootCanvas);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGButton);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFSComboBox);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGLabel);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGListView);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootIconBox);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGListTree);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGListTreeItem);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFileContainer);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGComboBox);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTextEdit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootBrowserLite),sizeof(TRootBrowserLite),-1,62720,"ROOT native GUI version of browser",G__setup_memvarTRootBrowserLite,G__setup_memfuncTRootBrowserLite);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TFunction);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGWidget);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMenuEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootDialog),sizeof(TRootDialog),-1,62720,"Native GUI method argument prompt dialog box",G__setup_memvarTRootDialog,G__setup_memfuncTRootDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootContextMenu),sizeof(TRootContextMenu),-1,65280,"ROOT native GUI context sensitive popup menu",G__setup_memvarTRootContextMenu,G__setup_memfuncTRootContextMenu);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootControlBar),sizeof(TRootControlBar),-1,62720,"ROOT native GUI implementation of TControlBar",G__setup_memvarTRootControlBar,G__setup_memfuncTRootControlBar);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTextView);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootHelpDialog),sizeof(TRootHelpDialog),-1,65280,"Dialog to display help text",G__setup_memvarTRootHelpDialog,G__setup_memfuncTRootHelpDialog);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootEmbeddedContainer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootEmbeddedCanvas),sizeof(TRootEmbeddedCanvas),-1,65280,"A ROOT TCanvas that can be embedded in a TGFrame",G__setup_memvarTRootEmbeddedCanvas,G__setup_memfuncTRootEmbeddedCanvas);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTextEntry);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTextBuffer);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTab);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TColorWheel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGColorPalette),sizeof(TGColorPalette),-1,65280,"Color palette widget",G__setup_memvarTGColorPalette,G__setup_memfuncTGColorPalette);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGColorPick),sizeof(TGColorPick),-1,62720,"Color picker widget",G__setup_memvarTGColorPick,G__setup_memfuncTGColorPick);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGColorDialog),sizeof(TGColorDialog),-1,65280,"Color selection dialog",G__setup_memvarTGColorDialog,G__setup_memfuncTGColorDialog);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGPictureButton);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGCheckButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGColorFrame),sizeof(TGColorFrame),-1,65280,"Frame for color cell",G__setup_memvarTGColorFrame,G__setup_memfuncTGColorFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TG16ColorSelector),sizeof(TG16ColorSelector),-1,65280,"16 color cells",G__setup_memvarTG16ColorSelector,G__setup_memfuncTG16ColorSelector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGColorPopup),sizeof(TGColorPopup),-1,65280,"Color selector popup",G__setup_memvarTGColorPopup,G__setup_memfuncTGColorPopup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGColorSelect),sizeof(TGColorSelect),-1,65280,"Color selection checkbutton",G__setup_memvarTGColorSelect,G__setup_memfuncTGColorSelect);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGListBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFontDialog),sizeof(TGFontDialog),-1,62720,"Font selection dialog",G__setup_memvarTGFontDialog,G__setup_memfuncTGFontDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFontDialogcLcLFontProp_t),sizeof(TGFontDialog::FontProp_t),-1,0,(char*)NULL,G__setup_memvarTGFontDialogcLcLFontProp_t,G__setup_memfuncTGFontDialogcLcLFontProp_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGDockButton),sizeof(TGDockButton),-1,62720,"Dock button",G__setup_memvarTGDockButton,G__setup_memfuncTGDockButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGDockHideButton),sizeof(TGDockHideButton),-1,61696,"Hide dock button",G__setup_memvarTGDockHideButton,G__setup_memfuncTGDockHideButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGUndockedFrame),sizeof(TGUndockedFrame),-1,65280,"Undocked frame",G__setup_memvarTGUndockedFrame,G__setup_memfuncTGUndockedFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EMdiResizingModes),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EMdiHints),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EMdiArrangementModes),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EMdiGeometryMask),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiMenuBar),sizeof(TGMdiMenuBar),-1,62464,"MDI menu bar",G__setup_memvarTGMdiMenuBar,G__setup_memfuncTGMdiMenuBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiContainer),sizeof(TGMdiContainer),-1,61440,"MDI container",G__setup_memvarTGMdiContainer,G__setup_memfuncTGMdiContainer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiDecorFrame),sizeof(TGMdiDecorFrame),-1,62464,"MDI Decor Frame",G__setup_memvarTGMdiDecorFrame,G__setup_memfuncTGMdiDecorFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiFrame),sizeof(TGMdiFrame),-1,62464,"MDI Frame",G__setup_memvarTGMdiFrame,G__setup_memfuncTGMdiFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiFrameList),sizeof(TGMdiFrameList),-1,1024,"MDI Frame list",G__setup_memvarTGMdiFrameList,G__setup_memfuncTGMdiFrameList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiMainFrame),sizeof(TGMdiMainFrame),-1,62464,"MDI main frame",G__setup_memvarTGMdiMainFrame,G__setup_memfuncTGMdiMainFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiGeometry),sizeof(TGMdiGeometry),-1,1024,"MDI Geometry",G__setup_memvarTGMdiGeometry,G__setup_memfuncTGMdiGeometry);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiMainFramecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiTitleIcon),sizeof(TGMdiTitleIcon),-1,62464,"MDI Title Icon",G__setup_memvarTGMdiTitleIcon,G__setup_memfuncTGMdiTitleIcon);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiButtons),sizeof(TGMdiButtons),-1,62464,"MDI Buttons Frame",G__setup_memvarTGMdiButtons,G__setup_memfuncTGMdiButtons);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TImage);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGIcon);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiFramecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EMdiResizerPlacement),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiTitleBar),sizeof(TGMdiTitleBar),-1,62464,"MDI Title Bar",G__setup_memvarTGMdiTitleBar,G__setup_memfuncTGMdiTitleBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiWinResizer),sizeof(TGMdiWinResizer),-1,61440,"Window Resizer",G__setup_memvarTGMdiWinResizer,G__setup_memfuncTGMdiWinResizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiVerticalWinResizer),sizeof(TGMdiVerticalWinResizer),-1,61440,"Vertical Window Resizer",G__setup_memvarTGMdiVerticalWinResizer,G__setup_memfuncTGMdiVerticalWinResizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiHorizontalWinResizer),sizeof(TGMdiHorizontalWinResizer),-1,61440,"Horizontal Window Resizer",G__setup_memvarTGMdiHorizontalWinResizer,G__setup_memfuncTGMdiHorizontalWinResizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiCornerWinResizer),sizeof(TGMdiCornerWinResizer),-1,61440,"Corner Window Resizer",G__setup_memvarTGMdiCornerWinResizer,G__setup_memfuncTGMdiCornerWinResizer);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGMdiDecorFramecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EDragType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TVirtualDragManager),sizeof(TVirtualDragManager),-1,1280,"drag and drop manager",G__setup_memvarTVirtualDragManager,G__setup_memfuncTVirtualDragManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_EGuiBldAction),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGuiBldAction),sizeof(TGuiBldAction),-1,62720,"gui builder action",G__setup_memvarTGuiBldAction,G__setup_memfuncTGuiBldAction);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGuiBuilder),sizeof(TGuiBuilder),-1,1280,"ABC for gui builder",G__setup_memvarTGuiBuilder,G__setup_memfuncTGuiBuilder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGRedirectOutputGuard),sizeof(TGRedirectOutputGuard),-1,33792,"Exception safe output redirection",G__setup_memvarTGRedirectOutputGuard,G__setup_memfuncTGRedirectOutputGuard);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGPasswdDialog),sizeof(TGPasswdDialog),-1,33792,"Dialog for entering passwords",G__setup_memvarTGPasswdDialog,G__setup_memfuncTGPasswdDialog);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGText);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TMacro);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTextEditor),sizeof(TGTextEditor),-1,62720,"Simple text editor using TGTextEdit widget",G__setup_memvarTGTextEditor,G__setup_memfuncTGTextEditor);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TVectorTlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSpeedo),sizeof(TGSpeedo),-1,62720,"Base class for analog meter widget",G__setup_memvarTGSpeedo,G__setup_memfuncTGSpeedo);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSpeedocLcLEGlowColor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGDragWindow),sizeof(TGDragWindow),-1,62464,"Window used for dragging",G__setup_memvarTGDragWindow,G__setup_memfuncTGDragWindow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTable),sizeof(TGTable),-1,62720,"A table used to visualize data from diffent sources.",G__setup_memvarTGTable,G__setup_memfuncTGTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTableCell),sizeof(TGTableCell),-1,62720,"A single cell in a TGTable.",G__setup_memvarTGTableCell,G__setup_memfuncTGTableCell);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_EHeaderType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTableHeader),sizeof(TGTableHeader),-1,62720,"Header for use in TGTable.",G__setup_memvarTGTableHeader,G__setup_memfuncTGTableHeader);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TVirtualTableInterface);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTableFrame),sizeof(TGTableFrame),-1,33792,"A frame used internally by TGTable.",G__setup_memvarTGTableFrame,G__setup_memfuncTGTableFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGTableHeaderFrame),sizeof(TGTableHeaderFrame),-1,62464,"A frame used internally by TGTable.",G__setup_memvarTGTableHeaderFrame,G__setup_memfuncTGTableHeaderFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TTableRange),sizeof(TTableRange),-1,1280,"Range used in TGTable.",G__setup_memvarTTableRange,G__setup_memfuncTTableRange);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSimpleTableInterface),sizeof(TGSimpleTableInterface),-1,33792,"Interface to data in a 2D array of Double_t",G__setup_memvarTGSimpleTableInterface,G__setup_memfuncTGSimpleTableInterface);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSimpleTable),sizeof(TGSimpleTable),-1,62464,"A simple table that owns it's interface.",G__setup_memvarTGSimpleTable,G__setup_memfuncTGSimpleTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGCommandPlugin),sizeof(TGCommandPlugin),-1,62464,"Command (I/O redirection) plugin for the new ROOT Browser",G__setup_memvarTGCommandPlugin,G__setup_memfuncTGCommandPlugin);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootBrowser),sizeof(TRootBrowser),-1,65280,"New ROOT Browser",G__setup_memvarTRootBrowser,G__setup_memfuncTRootBrowser);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TSystemDirectory);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TSystemFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGFileBrowser),sizeof(TGFileBrowser),-1,62464,"File browser.",G__setup_memvarTGFileBrowser,G__setup_memfuncTGFileBrowser);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_listlETGListTreeItemmUcOallocatorlETGListTreeItemmUgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGVSplitter);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGHSplitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TBrowserPlugin),sizeof(TBrowserPlugin),-1,62464,"basic plugin description class",G__setup_memvarTBrowserPlugin,G__setup_memfuncTBrowserPlugin);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TRootBrowsercLcLEInsertPosition);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TMap);
   G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSplitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGRectMap),sizeof(TGRectMap),-1,65024,"Rectangle used in TMap",G__setup_memvarTGRectMap,G__setup_memfuncTGRectMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSplitTool),sizeof(TGSplitTool),-1,65280,"Split frame tool utility",G__setup_memvarTGSplitTool,G__setup_memfuncTGSplitTool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGSplitFrame),sizeof(TGSplitFrame),-1,65280,"Splittable composite frame",G__setup_memvarTGSplitFrame,G__setup_memfuncTGSplitFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGShapedFrame),sizeof(TGShapedFrame),-1,65280,"Shaped composite frame",G__setup_memvarTGShapedFrame,G__setup_memfuncTGShapedFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui3LN_TGEventHandler),sizeof(TGEventHandler),-1,65024,"Abstract event handler",G__setup_memvarTGEventHandler,G__setup_memfuncTGEventHandler);
}
extern "C" void G__cpp_setupG__Gui3(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Gui3()");
  G__set_cpp_environmentG__Gui3();
  G__cpp_setup_tagtableG__Gui3();

  G__cpp_setup_inheritanceG__Gui3();

  G__cpp_setup_typetableG__Gui3();

  G__cpp_setup_memvarG__Gui3();

  G__cpp_setup_memfuncG__Gui3();
  G__cpp_setup_globalG__Gui3();
  G__cpp_setup_funcG__Gui3();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Gui3();
  return;
}
class G__cpp_setup_initG__Gui3 {
  public:
    G__cpp_setup_initG__Gui3() { G__add_setup_func("G__Gui3",(G__incsetup)(&G__cpp_setupG__Gui3)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Gui3() { G__remove_setup_func("G__Gui3"); }
};
G__cpp_setup_initG__Gui3 G__cpp_setup_initializerG__Gui3;

---