//
// File generated by core/utils/src/rootcint_tmp at Wed Mar 14 10:30:55 2018

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

#define R__DICTIONARY_FILENAME guidIgeddIsrcdIG__Ged
#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__Ged.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// Direct notice to TROOT of the dictionary's loading.
namespace {
   static struct DictInit {
      DictInit() {
         ROOT::RegisterModule();
      }
   } __TheDictionaryInitializer;
}

// START OF SHADOWS

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

namespace ROOT {
   void TGedEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGedEditor(void *p = 0);
   static void *newArray_TGedEditor(Long_t size, void *p);
   static void delete_TGedEditor(void *p);
   static void deleteArray_TGedEditor(void *p);
   static void destruct_TGedEditor(void *p);
   static void streamer_TGedEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedEditor*)
   {
      ::TGedEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGedEditor", ::TGedEditor::Class_Version(), "include/TGedEditor.h", 50,
                  typeid(::TGedEditor), DefineBehavior(ptr, ptr),
                  &::TGedEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGedEditor) );
      instance.SetNew(&new_TGedEditor);
      instance.SetNewArray(&newArray_TGedEditor);
      instance.SetDelete(&delete_TGedEditor);
      instance.SetDeleteArray(&deleteArray_TGedEditor);
      instance.SetDestructor(&destruct_TGedEditor);
      instance.SetStreamerFunc(&streamer_TGedEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGedEditor*)
   {
      return GenerateInitInstanceLocal((::TGedEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGedFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedFrame(void *p);
   static void deleteArray_TGedFrame(void *p);
   static void destruct_TGedFrame(void *p);
   static void streamer_TGedFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedNameFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGedNameFrame(void *p = 0);
   static void *newArray_TGedNameFrame(Long_t size, void *p);
   static void delete_TGedNameFrame(void *p);
   static void deleteArray_TGedNameFrame(void *p);
   static void destruct_TGedNameFrame(void *p);
   static void streamer_TGedNameFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedNameFrame*)
   {
      ::TGedNameFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedNameFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGedNameFrame", ::TGedNameFrame::Class_Version(), "include/TGedFrame.h", 94,
                  typeid(::TGedNameFrame), DefineBehavior(ptr, ptr),
                  &::TGedNameFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGedNameFrame) );
      instance.SetNew(&new_TGedNameFrame);
      instance.SetNewArray(&newArray_TGedNameFrame);
      instance.SetDelete(&delete_TGedNameFrame);
      instance.SetDeleteArray(&deleteArray_TGedNameFrame);
      instance.SetDestructor(&destruct_TGedNameFrame);
      instance.SetStreamerFunc(&streamer_TGedNameFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGedNameFrame*)
   {
      return GenerateInitInstanceLocal((::TGedNameFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedNameFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrowEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrowEditor(void *p = 0);
   static void *newArray_TArrowEditor(Long_t size, void *p);
   static void delete_TArrowEditor(void *p);
   static void deleteArray_TArrowEditor(void *p);
   static void destruct_TArrowEditor(void *p);
   static void streamer_TArrowEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedPatternSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedPatternSelect(void *p);
   static void deleteArray_TGedPatternSelect(void *p);
   static void destruct_TGedPatternSelect(void *p);
   static void streamer_TGedPatternSelect(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAttFillEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttFillEditor(void *p = 0);
   static void *newArray_TAttFillEditor(Long_t size, void *p);
   static void delete_TAttFillEditor(void *p);
   static void deleteArray_TAttFillEditor(void *p);
   static void destruct_TAttFillEditor(void *p);
   static void streamer_TAttFillEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAttLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttLineEditor(void *p = 0);
   static void *newArray_TAttLineEditor(Long_t size, void *p);
   static void delete_TAttLineEditor(void *p);
   static void deleteArray_TAttLineEditor(void *p);
   static void destruct_TAttLineEditor(void *p);
   static void streamer_TAttLineEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedMarkerSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedMarkerSelect(void *p);
   static void deleteArray_TGedMarkerSelect(void *p);
   static void destruct_TGedMarkerSelect(void *p);
   static void streamer_TGedMarkerSelect(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAttMarkerEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttMarkerEditor(void *p = 0);
   static void *newArray_TAttMarkerEditor(Long_t size, void *p);
   static void delete_TAttMarkerEditor(void *p);
   static void deleteArray_TAttMarkerEditor(void *p);
   static void destruct_TAttMarkerEditor(void *p);
   static void streamer_TAttMarkerEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAttTextEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttTextEditor(void *p = 0);
   static void *newArray_TAttTextEditor(Long_t size, void *p);
   static void delete_TAttTextEditor(void *p);
   static void deleteArray_TAttTextEditor(void *p);
   static void destruct_TAttTextEditor(void *p);
   static void streamer_TAttTextEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TAxisEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAxisEditor(void *p = 0);
   static void *newArray_TAxisEditor(Long_t size, void *p);
   static void delete_TAxisEditor(void *p);
   static void deleteArray_TAxisEditor(void *p);
   static void destruct_TAxisEditor(void *p);
   static void streamer_TAxisEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TCurlyArcEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCurlyArcEditor(void *p = 0);
   static void *newArray_TCurlyArcEditor(Long_t size, void *p);
   static void delete_TCurlyArcEditor(void *p);
   static void deleteArray_TCurlyArcEditor(void *p);
   static void destruct_TCurlyArcEditor(void *p);
   static void streamer_TCurlyArcEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TCurlyLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCurlyLineEditor(void *p = 0);
   static void *newArray_TCurlyLineEditor(Long_t size, void *p);
   static void delete_TCurlyLineEditor(void *p);
   static void deleteArray_TCurlyLineEditor(void *p);
   static void destruct_TCurlyLineEditor(void *p);
   static void streamer_TCurlyLineEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TF1Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TF1Editor(void *p = 0);
   static void *newArray_TF1Editor(Long_t size, void *p);
   static void delete_TF1Editor(void *p);
   static void deleteArray_TF1Editor(void *p);
   static void destruct_TF1Editor(void *p);
   static void streamer_TF1Editor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TFrameEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFrameEditor(void *p = 0);
   static void *newArray_TFrameEditor(Long_t size, void *p);
   static void delete_TFrameEditor(void *p);
   static void deleteArray_TFrameEditor(void *p);
   static void destruct_TFrameEditor(void *p);
   static void streamer_TFrameEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TFunctionParametersDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TFunctionParametersDialog(void *p);
   static void deleteArray_TFunctionParametersDialog(void *p);
   static void destruct_TFunctionParametersDialog(void *p);
   static void streamer_TFunctionParametersDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedPopup(void *p);
   static void deleteArray_TGedPopup(void *p);
   static void destruct_TGedPopup(void *p);
   static void streamer_TGedPopup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedPatternFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedPatternFrame(void *p);
   static void deleteArray_TGedPatternFrame(void *p);
   static void destruct_TGedPatternFrame(void *p);
   static void streamer_TGedPatternFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedPatternSelector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedPatternSelector(void *p);
   static void deleteArray_TGedPatternSelector(void *p);
   static void destruct_TGedPatternSelector(void *p);
   static void streamer_TGedPatternSelector(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedPatternPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedPatternPopup(void *p);
   static void deleteArray_TGedPatternPopup(void *p);
   static void destruct_TGedPatternPopup(void *p);
   static void streamer_TGedPatternPopup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedSelect(void *p);
   static void deleteArray_TGedSelect(void *p);
   static void destruct_TGedSelect(void *p);
   static void streamer_TGedSelect(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGedMarkerPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGedMarkerPopup(void *p);
   static void deleteArray_TGedMarkerPopup(void *p);
   static void destruct_TGedMarkerPopup(void *p);
   static void streamer_TGedMarkerPopup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGraphEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphEditor(void *p = 0);
   static void *newArray_TGraphEditor(Long_t size, void *p);
   static void delete_TGraphEditor(void *p);
   static void deleteArray_TGraphEditor(void *p);
   static void destruct_TGraphEditor(void *p);
   static void streamer_TGraphEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TH1Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1Editor(void *p = 0);
   static void *newArray_TH1Editor(Long_t size, void *p);
   static void delete_TH1Editor(void *p);
   static void deleteArray_TH1Editor(void *p);
   static void destruct_TH1Editor(void *p);
   static void streamer_TH1Editor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TH2Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2Editor(void *p = 0);
   static void *newArray_TH2Editor(Long_t size, void *p);
   static void delete_TH2Editor(void *p);
   static void deleteArray_TH2Editor(void *p);
   static void destruct_TH2Editor(void *p);
   static void streamer_TH2Editor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLineEditor(void *p = 0);
   static void *newArray_TLineEditor(Long_t size, void *p);
   static void delete_TLineEditor(void *p);
   static void deleteArray_TLineEditor(void *p);
   static void destruct_TLineEditor(void *p);
   static void streamer_TLineEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPadEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPadEditor(void *p = 0);
   static void *newArray_TPadEditor(Long_t size, void *p);
   static void delete_TPadEditor(void *p);
   static void deleteArray_TPadEditor(void *p);
   static void destruct_TPadEditor(void *p);
   static void streamer_TPadEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPaveStatsEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPaveStatsEditor(void *p = 0);
   static void *newArray_TPaveStatsEditor(Long_t size, void *p);
   static void delete_TPaveStatsEditor(void *p);
   static void deleteArray_TPaveStatsEditor(void *p);
   static void destruct_TPaveStatsEditor(void *p);
   static void streamer_TPaveStatsEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPieEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPieEditor(void *p = 0);
   static void *newArray_TPieEditor(Long_t size, void *p);
   static void delete_TPieEditor(void *p);
   static void deleteArray_TPieEditor(void *p);
   static void destruct_TPieEditor(void *p);
   static void streamer_TPieEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPieSliceEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPieSliceEditor(void *p = 0);
   static void *newArray_TPieSliceEditor(Long_t size, void *p);
   static void delete_TPieSliceEditor(void *p);
   static void deleteArray_TPieSliceEditor(void *p);
   static void destruct_TPieSliceEditor(void *p);
   static void streamer_TPieSliceEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TStyleManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStyleManager(void *p);
   static void deleteArray_TStyleManager(void *p);
   static void destruct_TStyleManager(void *p);
   static void streamer_TStyleManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TStyleDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStyleDialog(void *p);
   static void deleteArray_TStyleDialog(void *p);
   static void destruct_TStyleDialog(void *p);
   static void streamer_TStyleDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TStylePreview_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStylePreview(void *p);
   static void deleteArray_TStylePreview(void *p);
   static void destruct_TStylePreview(void *p);
   static void streamer_TStylePreview(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TTextEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTextEditor(void *p = 0);
   static void *newArray_TTextEditor(Long_t size, void *p);
   static void delete_TTextEditor(void *p);
   static void deleteArray_TTextEditor(void *p);
   static void destruct_TTextEditor(void *p);
   static void streamer_TTextEditor(TBuffer &buf, void *obj);

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

//______________________________________________________________________________
atomic_TClass_ptr TGedEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedFrame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedNameFrame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TArrowEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedPatternSelect::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TAttFillEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TAttLineEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedMarkerSelect::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TAttMarkerEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TAttTextEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TAxisEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TCurlyArcEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TCurlyLineEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TF1Editor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TFrameEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TFunctionParametersDialog::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedPopup::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedPatternFrame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedPatternSelector::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedPatternPopup::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedSelect::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGedMarkerPopup::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TGraphEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TH1Editor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TH2Editor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TLineEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TPadEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TPaveStatsEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TPieEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TPieSliceEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TStyleManager::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TStyleDialog::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TStylePreview::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TTextEditor::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGedFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGedFrame.
      TClass *R__cl = ::TGedFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInit", &fInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModelClass", &fModelClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAvoidSignal", &fAvoidSignal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtraTabs", &fExtraTabs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPriority", &fPriority);
      TGCompositeFrame::ShowMembers(R__insp);
}

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

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGedNameFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGedNameFrame.
      TClass *R__cl = ::TGedNameFrame::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(), "*f1", &f1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f2", &f2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGedNameFrame(void *p) {
      return  p ? new(p) ::TGedNameFrame : new ::TGedNameFrame;
   }
   static void *newArray_TGedNameFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGedNameFrame[nElements] : new ::TGedNameFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGedNameFrame(void *p) {
      delete ((::TGedNameFrame*)p);
   }
   static void deleteArray_TGedNameFrame(void *p) {
      delete [] ((::TGedNameFrame*)p);
   }
   static void destruct_TGedNameFrame(void *p) {
      typedef ::TGedNameFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGedNameFrame(TBuffer &buf, void *obj) {
      ((::TGedNameFrame*)obj)->::TGedNameFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGedNameFrame

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

   TGedFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrowEditor(void *p) {
      return  p ? new(p) ::TArrowEditor : new ::TArrowEditor;
   }
   static void *newArray_TArrowEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TArrowEditor[nElements] : new ::TArrowEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrowEditor(void *p) {
      delete ((::TArrowEditor*)p);
   }
   static void deleteArray_TArrowEditor(void *p) {
      delete [] ((::TArrowEditor*)p);
   }
   static void destruct_TArrowEditor(void *p) {
      typedef ::TArrowEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrowEditor(TBuffer &buf, void *obj) {
      ((::TArrowEditor*)obj)->::TArrowEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrowEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TLineEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLineEditor.
      TClass *R__cl = ::TLineEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLine", &fLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartPointX", &fStartPointX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartPointY", &fStartPointY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndPointX", &fEndPointX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndPointY", &fEndPointY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVertical", &fVertical);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHorizontal", &fHorizontal);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLineEditor(void *p) {
      return  p ? new(p) ::TLineEditor : new ::TLineEditor;
   }
   static void *newArray_TLineEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TLineEditor[nElements] : new ::TLineEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLineEditor(void *p) {
      delete ((::TLineEditor*)p);
   }
   static void deleteArray_TLineEditor(void *p) {
      delete [] ((::TLineEditor*)p);
   }
   static void destruct_TLineEditor(void *p) {
      typedef ::TLineEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TLineEditor(TBuffer &buf, void *obj) {
      ((::TLineEditor*)obj)->::TLineEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TLineEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TAttFillEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttFillEditor.
      TClass *R__cl = ::TAttFillEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttFill", &fAttFill);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPatternSelect", &fPatternSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlphaField", &fAlphaField);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttFillEditor(void *p) {
      return  p ? new(p) ::TAttFillEditor : new ::TAttFillEditor;
   }
   static void *newArray_TAttFillEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TAttFillEditor[nElements] : new ::TAttFillEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttFillEditor(void *p) {
      delete ((::TAttFillEditor*)p);
   }
   static void deleteArray_TAttFillEditor(void *p) {
      delete [] ((::TAttFillEditor*)p);
   }
   static void destruct_TAttFillEditor(void *p) {
      typedef ::TAttFillEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttFillEditor(TBuffer &buf, void *obj) {
      ((::TAttFillEditor*)obj)->::TAttFillEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttFillEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TAttLineEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttLineEditor.
      TClass *R__cl = ::TAttLineEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttLine", &fAttLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyleCombo", &fStyleCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWidthCombo", &fWidthCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlphaField", &fAlphaField);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttLineEditor(void *p) {
      return  p ? new(p) ::TAttLineEditor : new ::TAttLineEditor;
   }
   static void *newArray_TAttLineEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TAttLineEditor[nElements] : new ::TAttLineEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttLineEditor(void *p) {
      delete ((::TAttLineEditor*)p);
   }
   static void deleteArray_TAttLineEditor(void *p) {
      delete [] ((::TAttLineEditor*)p);
   }
   static void destruct_TAttLineEditor(void *p) {
      typedef ::TAttLineEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttLineEditor(TBuffer &buf, void *obj) {
      ((::TAttLineEditor*)obj)->::TAttLineEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttLineEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TAttMarkerEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttMarkerEditor.
      TClass *R__cl = ::TAttMarkerEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttMarker", &fAttMarker);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerSize", &fMarkerSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerType", &fMarkerType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizeForText", &fSizeForText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlphaField", &fAlphaField);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttMarkerEditor(void *p) {
      return  p ? new(p) ::TAttMarkerEditor : new ::TAttMarkerEditor;
   }
   static void *newArray_TAttMarkerEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TAttMarkerEditor[nElements] : new ::TAttMarkerEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttMarkerEditor(void *p) {
      delete ((::TAttMarkerEditor*)p);
   }
   static void deleteArray_TAttMarkerEditor(void *p) {
      delete [] ((::TAttMarkerEditor*)p);
   }
   static void destruct_TAttMarkerEditor(void *p) {
      typedef ::TAttMarkerEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttMarkerEditor(TBuffer &buf, void *obj) {
      ((::TAttMarkerEditor*)obj)->::TAttMarkerEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttMarkerEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TAttTextEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttTextEditor.
      TClass *R__cl = ::TAttTextEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttText", &fAttText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSizeCombo", &fSizeCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlignCombo", &fAlignCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlphaField", &fAlphaField);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttTextEditor(void *p) {
      return  p ? new(p) ::TAttTextEditor : new ::TAttTextEditor;
   }
   static void *newArray_TAttTextEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TAttTextEditor[nElements] : new ::TAttTextEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttTextEditor(void *p) {
      delete ((::TAttTextEditor*)p);
   }
   static void deleteArray_TAttTextEditor(void *p) {
      delete [] ((::TAttTextEditor*)p);
   }
   static void destruct_TAttTextEditor(void *p) {
      typedef ::TAttTextEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttTextEditor(TBuffer &buf, void *obj) {
      ((::TAttTextEditor*)obj)->::TAttTextEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttTextEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TAxisEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAxisEditor.
      TClass *R__cl = ::TAxisEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxis", &fAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxisColor", &fAxisColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogAxis", &fLogAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTickLength", &fTickLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiv1", &fDiv1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiv2", &fDiv2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiv3", &fDiv3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptimize", &fOptimize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTicksBoth", &fTicksBoth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMoreLog", &fMoreLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTicksFlag", &fTicksFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleColor", &fTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFont", &fTitleFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleSize", &fTitleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleOffset", &fTitleOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCentered", &fCentered);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotated", &fRotated);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelColor", &fLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelFont", &fLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelPrec", &fLabelPrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelSize", &fLabelSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelOffset", &fLabelOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNoExponent", &fNoExponent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDecimal", &fDecimal);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAxisEditor(void *p) {
      return  p ? new(p) ::TAxisEditor : new ::TAxisEditor;
   }
   static void *newArray_TAxisEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TAxisEditor[nElements] : new ::TAxisEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAxisEditor(void *p) {
      delete ((::TAxisEditor*)p);
   }
   static void deleteArray_TAxisEditor(void *p) {
      delete [] ((::TAxisEditor*)p);
   }
   static void destruct_TAxisEditor(void *p) {
      typedef ::TAxisEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAxisEditor(TBuffer &buf, void *obj) {
      ((::TAxisEditor*)obj)->::TAxisEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAxisEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TFrameEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFrameEditor.
      TClass *R__cl = ::TFrameEditor::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(), "*fBmode", &fBmode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode0", &fBmode0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode1", &fBmode1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmodelh", &fBmodelh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBsize", &fBsize);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFrameEditor(void *p) {
      return  p ? new(p) ::TFrameEditor : new ::TFrameEditor;
   }
   static void *newArray_TFrameEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TFrameEditor[nElements] : new ::TFrameEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFrameEditor(void *p) {
      delete ((::TFrameEditor*)p);
   }
   static void deleteArray_TFrameEditor(void *p) {
      delete [] ((::TFrameEditor*)p);
   }
   static void destruct_TFrameEditor(void *p) {
      typedef ::TFrameEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFrameEditor(TBuffer &buf, void *obj) {
      ((::TFrameEditor*)obj)->::TFrameEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFrameEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGraphEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphEditor.
      TClass *R__cl = ::TGraphEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawShape", &fDrawShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraph", &fGraph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fgr", &fgr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape0", &fShape0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape1", &fShape1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape2", &fShape2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape3", &fShape3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape1lh", &fShape1lh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerOnOff", &fMarkerOnOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWidthCombo", &fWidthCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExSide", &fExSide);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphEditor(void *p) {
      return  p ? new(p) ::TGraphEditor : new ::TGraphEditor;
   }
   static void *newArray_TGraphEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphEditor[nElements] : new ::TGraphEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphEditor(void *p) {
      delete ((::TGraphEditor*)p);
   }
   static void deleteArray_TGraphEditor(void *p) {
      delete [] ((::TGraphEditor*)p);
   }
   static void destruct_TGraphEditor(void *p) {
      typedef ::TGraphEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGraphEditor(TBuffer &buf, void *obj) {
      ((::TGraphEditor*)obj)->::TGraphEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGraphEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TTextEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTextEditor.
      TClass *R__cl = ::TTextEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditedText", &fEditedText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fText", &fText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAngle", &fAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXpos", &fXpos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYpos", &fYpos);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTextEditor(void *p) {
      return  p ? new(p) ::TTextEditor : new ::TTextEditor;
   }
   static void *newArray_TTextEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TTextEditor[nElements] : new ::TTextEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTextEditor(void *p) {
      delete ((::TTextEditor*)p);
   }
   static void deleteArray_TTextEditor(void *p) {
      delete [] ((::TTextEditor*)p);
   }
   static void destruct_TTextEditor(void *p) {
      typedef ::TTextEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTextEditor(TBuffer &buf, void *obj) {
      ((::TTextEditor*)obj)->::TTextEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTextEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TPieEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPieEditor.
      TClass *R__cl = ::TPieEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawShape", &fDrawShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPie", &fPie);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fgr", &fgr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLblDirH", &fLblDirH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLblDirR", &fLblDirR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLblDirT", &fLblDirT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape1lh", &fShape1lh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutlineOnOff", &fOutlineOnOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIs3D", &fIs3D);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3DHeight", &f3DHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3DAngle", &f3DAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSizeCombo", &fSizeCombo);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPieEditor(void *p) {
      return  p ? new(p) ::TPieEditor : new ::TPieEditor;
   }
   static void *newArray_TPieEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TPieEditor[nElements] : new ::TPieEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPieEditor(void *p) {
      delete ((::TPieEditor*)p);
   }
   static void deleteArray_TPieEditor(void *p) {
      delete [] ((::TPieEditor*)p);
   }
   static void destruct_TPieEditor(void *p) {
      typedef ::TPieEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPieEditor(TBuffer &buf, void *obj) {
      ((::TPieEditor*)obj)->::TPieEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPieEditor

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

   TGedFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPieSliceEditor(void *p) {
      return  p ? new(p) ::TPieSliceEditor : new ::TPieSliceEditor;
   }
   static void *newArray_TPieSliceEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TPieSliceEditor[nElements] : new ::TPieSliceEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPieSliceEditor(void *p) {
      delete ((::TPieSliceEditor*)p);
   }
   static void deleteArray_TPieSliceEditor(void *p) {
      delete [] ((::TPieSliceEditor*)p);
   }
   static void destruct_TPieSliceEditor(void *p) {
      typedef ::TPieSliceEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPieSliceEditor(TBuffer &buf, void *obj) {
      ((::TPieSliceEditor*)obj)->::TPieSliceEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPieSliceEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TH1Editor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH1Editor.
      TClass *R__cl = ::TH1Editor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSameOpt", &fSameOpt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBin", &fBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimGroup", &fDimGroup);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim", &fDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0", &fDim0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimlh", &fDimlh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0lh", &fDim0lh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoordsCombo", &fCoordsCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrorCombo", &fErrorCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistOnOff", &fHistOnOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddMarker", &fAddMarker);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddB", &fAddB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddBar", &fAddBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAdd", &fAdd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMakeHBar", &fMakeHBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddSimple", &fAddSimple);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarWidth", &fBarWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarOffset", &fBarOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddCombo", &fAddCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPercentCombo", &fPercentCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3", &f3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f6", &f6);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f7", &f7);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f8", &f8);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f9", &f9);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f10", &f10);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f11", &f11);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f12", &f12);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f15", &f15);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinCont", &fBinCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinCont1", &fBinCont1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinSlider", &fBinSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinSlider1", &fBinSlider1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinNumberEntry", &fBinNumberEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinNumberEntry1", &fBinNumberEntry1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinOffsetSld", &fBinOffsetSld);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOffsetNumberEntry", &fOffsetNumberEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlider", &fSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMin", &fSldMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMax", &fSldMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelaydraw", &fDelaydraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMake", &fMake);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMakeB", &fMakeB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx1old", &fPx1old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy1old", &fPy1old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx2old", &fPx2old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy2old", &fPy2old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1NDCold[3]", fP1NDCold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2NDCold[3]", fP2NDCold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3NDCold[3]", fP3NDCold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4NDCold[3]", fP4NDCold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1old[3]", fP1old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2old[3]", fP2old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3old[3]", fP3old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4old[3]", fP4old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP5old[3]", fP5old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP6old[3]", fP6old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP7old[3]", fP7old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP8old[3]", fP8old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinHist", &fBinHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldOffset", &fOldOffset);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1Editor(void *p) {
      return  p ? new(p) ::TH1Editor : new ::TH1Editor;
   }
   static void *newArray_TH1Editor(Long_t nElements, void *p) {
      return p ? new(p) ::TH1Editor[nElements] : new ::TH1Editor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1Editor(void *p) {
      delete ((::TH1Editor*)p);
   }
   static void deleteArray_TH1Editor(void *p) {
      delete [] ((::TH1Editor*)p);
   }
   static void destruct_TH1Editor(void *p) {
      typedef ::TH1Editor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH1Editor(TBuffer &buf, void *obj) {
      ((::TH1Editor*)obj)->::TH1Editor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH1Editor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TH2Editor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH2Editor.
      TClass *R__cl = ::TH2Editor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBin", &fBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFit", &fFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoordsCombo", &fCoordsCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContCombo", &fContCombo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColContLbl", &fColContLbl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColContLbl1", &fColContLbl1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimGroup", &fDimGroup);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim", &fDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0", &fDim0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimlh", &fDimlh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0lh", &fDim0lh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f6", &f6);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f9", &f9);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f12", &f12);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f13", &f13);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f38", &f38);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddError", &fAddError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddPalette", &fAddPalette);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddPalette1", &fAddPalette1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddArr", &fAddArr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddBox", &fAddBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddScat", &fAddScat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddCol", &fAddCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddFB", &fAddFB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddBB", &fAddBB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddText", &fAddText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContLevels", &fContLevels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContLevels1", &fContLevels1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarWidth", &fBarWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarOffset", &fBarOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXCont", &fBinXCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXSlider", &fBinXSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXNumberEntry", &fBinXNumberEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYSlider", &fBinYSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYNumberEntry", &fBinYNumberEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXCont1", &fBinXCont1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXSlider1", &fBinXSlider1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXNumberEntry1", &fBinXNumberEntry1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXOffsetNumberEntry", &fXOffsetNumberEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXBinOffsetSld", &fXBinOffsetSld);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYCont1", &fBinYCont1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYSlider1", &fBinYSlider1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYNumberEntry1", &fBinYNumberEntry1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYOffsetNumberEntry", &fYOffsetNumberEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYBinOffsetSld", &fYBinOffsetSld);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderX", &fSliderX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldXMin", &fSldXMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldXMax", &fSldXMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderY", &fSliderY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldYMin", &fSldYMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldYMax", &fSldYMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelaydraw", &fDelaydraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameColor", &fFrameColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFramePattern", &fFramePattern);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutString", &fCutString);
      R__insp.InspectMember(fCutString, "fCutString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx1old", &fPx1old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy1old", &fPy1old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx2old", &fPx2old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy2old", &fPy2old);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1oldx[3]", fP1oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2oldx[3]", fP2oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3oldx[3]", fP3oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4oldx[3]", fP4oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP5oldx[3]", fP5oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP6oldx[3]", fP6oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP7oldx[3]", fP7oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP8oldx[3]", fP8oldx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1oldy[3]", fP1oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2oldy[3]", fP2oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3oldy[3]", fP3oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4oldy[3]", fP4oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP5oldy[3]", fP5oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP6oldy[3]", fP6oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP7oldy[3]", fP7oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP8oldy[3]", fP8oldy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinHist", &fBinHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldXOffset", &fOldXOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldYOffset", &fOldYOffset);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2Editor(void *p) {
      return  p ? new(p) ::TH2Editor : new ::TH2Editor;
   }
   static void *newArray_TH2Editor(Long_t nElements, void *p) {
      return p ? new(p) ::TH2Editor[nElements] : new ::TH2Editor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2Editor(void *p) {
      delete ((::TH2Editor*)p);
   }
   static void deleteArray_TH2Editor(void *p) {
      delete [] ((::TH2Editor*)p);
   }
   static void destruct_TH2Editor(void *p) {
      typedef ::TH2Editor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH2Editor(TBuffer &buf, void *obj) {
      ((::TH2Editor*)obj)->::TH2Editor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH2Editor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TF1Editor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TF1Editor.
      TClass *R__cl = ::TF1Editor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF1", &fF1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNP", &fNP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParLabel", &fParLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawMode", &fDrawMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSetPars", &fSetPars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNXpoints", &fNXpoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderX", &fSliderX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMinX", &fSldMinX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMaxX", &fSldMaxX);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TF1Editor(void *p) {
      return  p ? new(p) ::TF1Editor : new ::TF1Editor;
   }
   static void *newArray_TF1Editor(Long_t nElements, void *p) {
      return p ? new(p) ::TF1Editor[nElements] : new ::TF1Editor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TF1Editor(void *p) {
      delete ((::TF1Editor*)p);
   }
   static void deleteArray_TF1Editor(void *p) {
      delete [] ((::TF1Editor*)p);
   }
   static void destruct_TF1Editor(void *p) {
      typedef ::TF1Editor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TF1Editor(TBuffer &buf, void *obj) {
      ((::TF1Editor*)obj)->::TF1Editor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TF1Editor

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TFunctionParametersDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFunctionParametersDialog.
      TClass *R__cl = ::TFunctionParametersDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc", &fFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFpad", &fFpad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNP", &fNP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPmin", &fPmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPmax", &fPmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPval", &fPval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPerr", &fPerr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangexmin", &fRangexmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangexmax", &fRangexmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRXmin", &fRXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRXmax", &fRXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContNam", &fContNam);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContVal", &fContVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContFix", &fContFix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContSld", &fContSld);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContMin", &fContMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContMax", &fContMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParNam", &fParNam);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParFix", &fParFix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParVal", &fParVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParMin", &fParMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParMax", &fParMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParSld", &fParSld);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpdate", &fUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReset", &fReset);
      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(), "fHasChanges", &fHasChanges);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImmediateDraw", &fImmediateDraw);
      TGTransientFrame::ShowMembers(R__insp);
}

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

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TPaveStatsEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPaveStatsEditor.
      TClass *R__cl = ::TPaveStatsEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaveStats", &fPaveStats);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistoName", &fHistoName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMean", &fMean);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRMS", &fRMS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnderflow", &fUnderflow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverflow", &fOverflow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegral", &fIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSkewness", &fSkewness);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKurtosis", &fKurtosis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatsErrors", &fStatsErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNameValues", &fNameValues);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrors", &fErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChisquare", &fChisquare);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProbability", &fProbability);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPaveStatsEditor(void *p) {
      return  p ? new(p) ::TPaveStatsEditor : new ::TPaveStatsEditor;
   }
   static void *newArray_TPaveStatsEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TPaveStatsEditor[nElements] : new ::TPaveStatsEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPaveStatsEditor(void *p) {
      delete ((::TPaveStatsEditor*)p);
   }
   static void deleteArray_TPaveStatsEditor(void *p) {
      delete [] ((::TPaveStatsEditor*)p);
   }
   static void destruct_TPaveStatsEditor(void *p) {
      typedef ::TPaveStatsEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPaveStatsEditor(TBuffer &buf, void *obj) {
      ((::TPaveStatsEditor*)obj)->::TPaveStatsEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPaveStatsEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TPadEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPadEditor.
      TClass *R__cl = ::TPadEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadPointer", &fPadPointer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditable", &fEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrosshair", &fCrosshair);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFixedAR", &fFixedAR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridX", &fGridX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridY", &fGridY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogX", &fLogX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogY", &fLogY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogZ", &fLogZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTickX", &fTickX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTickY", &fTickY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode", &fBmode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode0", &fBmode0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode1", &fBmode1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmodelh", &fBmodelh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBsize", &fBsize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBgroup", &fBgroup);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPadEditor(void *p) {
      return  p ? new(p) ::TPadEditor : new ::TPadEditor;
   }
   static void *newArray_TPadEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TPadEditor[nElements] : new ::TPadEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPadEditor(void *p) {
      delete ((::TPadEditor*)p);
   }
   static void deleteArray_TPadEditor(void *p) {
      delete [] ((::TPadEditor*)p);
   }
   static void destruct_TPadEditor(void *p) {
      typedef ::TPadEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPadEditor(TBuffer &buf, void *obj) {
      ((::TPadEditor*)obj)->::TPadEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPadEditor

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

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

//______________________________________________________________________________
void TGedEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGedEditor.
      TClass *R__cl = ::TGedEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameMap", &fFrameMap);
      R__insp.InspectMember(fFrameMap, "fFrameMap.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExclMap", &fExclMap);
      R__insp.InspectMember(fExclMap, "fExclMap.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGedFrames", &fGedFrames);
      R__insp.InspectMember(fGedFrames, "fGedFrames.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCan", &fCan);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreatedTabs", &fCreatedTabs);
      R__insp.InspectMember(fCreatedTabs, "fCreatedTabs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisibleTabs", &fVisibleTabs);
      R__insp.InspectMember(fVisibleTabs, "fVisibleTabs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabContainer", &fTabContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModel", &fModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGlobal", &fGlobal);
      TVirtualPadEditor::ShowMembers(R__insp);
      TGMainFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGedEditor(void *p) {
      return  p ? new(p) ::TGedEditor : new ::TGedEditor;
   }
   static void *newArray_TGedEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGedEditor[nElements] : new ::TGedEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGedEditor(void *p) {
      delete ((::TGedEditor*)p);
   }
   static void deleteArray_TGedEditor(void *p) {
      delete [] ((::TGedEditor*)p);
   }
   static void destruct_TGedEditor(void *p) {
      typedef ::TGedEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGedEditor(TBuffer &buf, void *obj) {
      ((::TGedEditor*)obj)->::TGedEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGedEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TCurlyArcEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TCurlyArcEditor.
      TClass *R__cl = ::TCurlyArcEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurlyArc", &fCurlyArc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRadiusEntry", &fRadiusEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhiminEntry", &fPhiminEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhimaxEntry", &fPhimaxEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterXEntry", &fCenterXEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterYEntry", &fCenterYEntry);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCurlyArcEditor(void *p) {
      return  p ? new(p) ::TCurlyArcEditor : new ::TCurlyArcEditor;
   }
   static void *newArray_TCurlyArcEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TCurlyArcEditor[nElements] : new ::TCurlyArcEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCurlyArcEditor(void *p) {
      delete ((::TCurlyArcEditor*)p);
   }
   static void deleteArray_TCurlyArcEditor(void *p) {
      delete [] ((::TCurlyArcEditor*)p);
   }
   static void destruct_TCurlyArcEditor(void *p) {
      typedef ::TCurlyArcEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TCurlyArcEditor(TBuffer &buf, void *obj) {
      ((::TCurlyArcEditor*)obj)->::TCurlyArcEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TCurlyArcEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TCurlyLineEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TCurlyLineEditor.
      TClass *R__cl = ::TCurlyLineEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurlyLine", &fCurlyLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartXEntry", &fStartXEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndXEntry", &fEndXEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartYEntry", &fStartYEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndYEntry", &fEndYEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAmplitudeEntry", &fAmplitudeEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWaveLengthEntry", &fWaveLengthEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsWavy", &fIsWavy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartXFrame", &fStartXFrame);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCurlyLineEditor(void *p) {
      return  p ? new(p) ::TCurlyLineEditor : new ::TCurlyLineEditor;
   }
   static void *newArray_TCurlyLineEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TCurlyLineEditor[nElements] : new ::TCurlyLineEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCurlyLineEditor(void *p) {
      delete ((::TCurlyLineEditor*)p);
   }
   static void deleteArray_TCurlyLineEditor(void *p) {
      delete [] ((::TCurlyLineEditor*)p);
   }
   static void destruct_TCurlyLineEditor(void *p) {
      typedef ::TCurlyLineEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TCurlyLineEditor(TBuffer &buf, void *obj) {
      ((::TCurlyLineEditor*)obj)->::TCurlyLineEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TCurlyLineEditor

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

   TGCompositeFrame::Streamer(R__b);
}

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

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

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

   TGCheckButton::Streamer(R__b);
}

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

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

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGedPatternFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGedPatternFrame.
      TClass *R__cl = ::TGedPatternFrame::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(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPattern", &fPattern);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTipText[5]", fTipText);
      TGFrame::ShowMembers(R__insp);
}

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

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGedPatternSelector::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGedPatternSelector.
      TClass *R__cl = ::TGedPatternSelector::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[27]", &fCe);
      TGCompositeFrame::ShowMembers(R__insp);
}

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

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

   TGedPopup::Streamer(R__b);
}

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

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

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

   TGedSelect::Streamer(R__b);
}

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

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

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

   TGedSelect::Streamer(R__b);
}

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

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

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

   TGedPopup::Streamer(R__b);
}

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

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

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

   TGMainFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TStyleManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStyleManager.
      TClass *R__cl = ::TStyleManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurSelStyle", &fCurSelStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastChoice", &fLastChoice);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTimePreview", &fRealTimePreview);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurTabNum", &fCurTabNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurTabAxisNum", &fCurTabAxisNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSMWidth", &fSMWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSMHeight", &fSMHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyleChanged", &fStyleChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMoreAndNotLess", &fMoreAndNotLess);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigSlotConnected", &fSigSlotConnected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllAndNotCurrent", &fAllAndNotCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListFrame", &fTrashListFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListLayout", &fTrashListLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuStyle", &fMenuStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImportCascade", &fImportCascade);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHelp", &fMenuHelp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBar", &fToolBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarNew", &fToolBarNew);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarDelete", &fToolBarDelete);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportCanvas", &fToolBarImportCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportMacro", &fToolBarImportMacro);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarExport", &fToolBarExport);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarHelp", &fToolBarHelp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarNewPic", &fToolBarNewPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarDeletePic", &fToolBarDeletePic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportCanvasPic", &fToolBarImportCanvasPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportMacroPic", &fToolBarImportMacroPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarExportPic", &fToolBarExportPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarHelpPic", &fToolBarHelpPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHorizontal3DLine", &fHorizontal3DLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListLabel", &fListLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListComboBox", &fListComboBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurMacro", &fCurMacro);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurStylabel", &fCurStylabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurStyle", &fCurStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPadLabel", &fCurPadLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPadTextEntry", &fCurPadTextEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPad", &fCurPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurObjLabel", &fCurObjLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurObjTextEntry", &fCurObjTextEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurObj", &fCurObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviewButton", &fPreviewButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviewRealTime", &fPreviewRealTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviewWindow", &fPreviewWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMakeDefault", &fMakeDefault);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMakeDefaultPic", &fMakeDefaultPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnGroup", &fApplyOnGroup);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnAll", &fApplyOnAll);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnSel", &fApplyOnSel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnButton", &fApplyOnButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMoreLess", &fMoreLess);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBar", &fStatusBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionFrame", &fEditionFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionTab", &fEditionTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistosTab", &fHistosTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxisTab", &fAxisTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionButtonFrame", &fEditionButtonFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionHelp", &fEditionHelp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionUpdatePreview", &fEditionUpdatePreview);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionReset", &fEditionReset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFillColor", &fFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFillStyle", &fFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHatchesLineWidth", &fHatchesLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHatchesSpacing", &fHatchesSpacing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextColor", &fTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextSize", &fTextSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextSizeInPixels", &fTextSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextFont", &fTextFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextAlign", &fTextAlign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextAngle", &fTextAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineColor", &fLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineWidth", &fLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineStyle", &fLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineStyleEdit", &fLineStyleEdit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerColor", &fMarkerColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerStyle", &fMarkerStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerSize", &fMarkerSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScreenFactor", &fScreenFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasColor", &fCanvasColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefX", &fCanvasDefX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefY", &fCanvasDefY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefW", &fCanvasDefW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefH", &fCanvasDefH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasBorderMode", &fCanvasBorderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasBorderSize", &fCanvasBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptDateBool", &fOptDateBool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextColor", &fAttDateTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextSize", &fAttDateTextSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextSizeInPixels", &fAttDateTextSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptDateFormat", &fOptDateFormat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextFont", &fAttDateTextFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextAngle", &fAttDateTextAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextAlign", &fAttDateTextAlign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDateX", &fDateX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDateY", &fDateY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadLeftMargin", &fPadLeftMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadRightMargin", &fPadRightMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadTopMargin", &fPadTopMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadBottomMargin", &fPadBottomMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadBorderMode", &fPadBorderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadBorderSize", &fPadBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadColor", &fPadColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadTickX", &fPadTickX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadTickY", &fPadTickY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadGridX", &fPadGridX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadGridY", &fPadGridY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridColor", &fGridColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridWidth", &fGridWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridStyle", &fGridStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistFillColor", &fHistFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistFillStyle", &fHistFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistLineColor", &fHistLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistLineWidth", &fHistLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistLineStyle", &fHistLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarWidth", &fBarWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarOffset", &fBarOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistMinimumZero", &fHistMinimumZero);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaintTextFormat", &fPaintTextFormat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNumberContours", &fNumberContours);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegoInnerR", &fLegoInnerR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameFillColor", &fFrameFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameFillStyle", &fFrameFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameLineColor", &fFrameLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameLineWidth", &fFrameLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameLineStyle", &fFrameLineStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaletteEdit", &fPaletteEdit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameBorderMode", &fFrameBorderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameBorderSize", &fFrameBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncColor", &fFuncColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncWidth", &fFuncWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncStyle", &fFuncStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawBorder", &fDrawBorder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndErrorSize", &fEndErrorSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrorX", &fErrorX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimeOffsetDate", &fTimeOffsetDate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimeOffsetTime", &fTimeOffsetTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStripDecimals", &fStripDecimals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnXYZ", &fApplyOnXYZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleSize", &fXTitleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleSizeInPixels", &fXTitleSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleColor", &fXTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleOffset", &fXTitleOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleFont", &fXTitleFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelSize", &fXLabelSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelSizeInPixels", &fXLabelSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelColor", &fXLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelOffset", &fXLabelOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelFont", &fXLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXAxisColor", &fXAxisColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTickLength", &fXTickLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptLogx", &fOptLogx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivMain", &fXNdivMain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivSub", &fXNdivSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivSubSub", &fXNdivSubSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivisionsOptimize", &fXNdivisionsOptimize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleSize", &fYTitleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleSizeInPixels", &fYTitleSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleColor", &fYTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleOffset", &fYTitleOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleFont", &fYTitleFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelSize", &fYLabelSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelSizeInPixels", &fYLabelSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelColor", &fYLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelOffset", &fYLabelOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelFont", &fYLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYAxisColor", &fYAxisColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTickLength", &fYTickLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptLogy", &fOptLogy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivMain", &fYNdivMain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivSub", &fYNdivSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivSubSub", &fYNdivSubSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivisionsOptimize", &fYNdivisionsOptimize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleSize", &fZTitleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleSizeInPixels", &fZTitleSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleColor", &fZTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleOffset", &fZTitleOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleFont", &fZTitleFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelSize", &fZLabelSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelSizeInPixels", &fZLabelSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelColor", &fZLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelOffset", &fZLabelOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelFont", &fZLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZAxisColor", &fZAxisColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTickLength", &fZTickLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptLogz", &fOptLogz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivMain", &fZNdivMain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivSub", &fZNdivSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivSubSub", &fZNdivSubSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivisionsOptimize", &fZNdivisionsOptimize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptTitle", &fOptTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleColor", &fTitleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleStyle", &fTitleStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleTextColor", &fTitleTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFontSize", &fTitleFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFontSizeInPixels", &fTitleFontSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFont", &fTitleFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleAlign", &fTitleAlign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleBorderSizeLabel", &fTitleBorderSizeLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleBorderSize", &fTitleBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleX", &fTitleX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleY", &fTitleY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleW", &fTitleW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleH", &fTitleH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegendBorderSizeLabel", &fLegendBorderSizeLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegendBorderSize", &fLegendBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatColor", &fStatColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatStyle", &fStatStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatTextColor", &fStatTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFontSize", &fStatFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFontSizeInPixels", &fStatFontSizeInPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFont", &fStatFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatX", &fStatX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatY", &fStatY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatW", &fStatW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatH", &fStatH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatBorderSizeLabel", &fStatBorderSizeLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatBorderSize", &fStatBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatName", &fOptStatName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatEntries", &fOptStatEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatOverflow", &fOptStatOverflow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatMean", &fOptStatMean);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatUnderflow", &fOptStatUnderflow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatRMS", &fOptStatRMS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatSkewness", &fOptStatSkewness);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatIntegral", &fOptStatIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatKurtosis", &fOptStatKurtosis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatErrors", &fOptStatErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFormatLabel", &fStatFormatLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFormat", &fStatFormat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitValues", &fOptFitValues);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitErrors", &fOptFitErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitProbability", &fOptFitProbability);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitChi", &fOptFitChi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitFormatLabel", &fFitFormatLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitFormat", &fFitFormat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderPS", &fHeaderPS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitlePS", &fTitlePS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorModelPS", &fColorModelPS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorModelPSRGB", &fColorModelPSRGB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorModelPSCMYK", &fColorModelPSCMYK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineScalePS", &fLineScalePS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaperSizePredef", &fPaperSizePredef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPaperSizeEnCm", &fPaperSizeEnCm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaperSizeX", &fPaperSizeX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaperSizeY", &fPaperSizeY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandX", &fLayoutExpandX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXMargin", &fLayoutExpandXMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXY", &fLayoutExpandXY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXYMargin", &fLayoutExpandXYMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXCenterYMargin", &fLayoutExpandXCenterYMargin);
      TGMainFrame::ShowMembers(R__insp);
}

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

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

   TGTransientFrame::Streamer(R__b);
}

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

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

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TStyleDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStyleDialog.
      TClass *R__cl = ::TStyleDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyleManager", &fStyleManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fName", &fName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNameLabel", &fNameLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleLabel", &fTitleLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWarnLabel", &fWarnLabel);
      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(), "*fCurStyle", &fCurStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPad", &fCurPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListFrame", &fTrashListFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListLayout", &fTrashListLayout);
      TGTransientFrame::ShowMembers(R__insp);
}

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

/********************************************************
* gui/ged/src/G__Ged.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__Ged();

extern "C" void G__set_cpp_environmentG__Ged() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("HelpSMText.h");
  G__add_compiledheader("TArrowEditor.h");
  G__add_compiledheader("TAttFillEditor.h");
  G__add_compiledheader("TAttLineEditor.h");
  G__add_compiledheader("TAttMarkerEditor.h");
  G__add_compiledheader("TAttTextEditor.h");
  G__add_compiledheader("TAxisEditor.h");
  G__add_compiledheader("TCurlyArcEditor.h");
  G__add_compiledheader("TCurlyLineEditor.h");
  G__add_compiledheader("TF1Editor.h");
  G__add_compiledheader("TFrameEditor.h");
  G__add_compiledheader("TFunctionParametersDialog.h");
  G__add_compiledheader("TGedEditor.h");
  G__add_compiledheader("TGedFrame.h");
  G__add_compiledheader("TGedMarkerSelect.h");
  G__add_compiledheader("TGedPatternSelect.h");
  G__add_compiledheader("TGraphEditor.h");
  G__add_compiledheader("TH1Editor.h");
  G__add_compiledheader("TH2Editor.h");
  G__add_compiledheader("TLineEditor.h");
  G__add_compiledheader("TPadEditor.h");
  G__add_compiledheader("TPaveStatsEditor.h");
  G__add_compiledheader("TPieEditor.h");
  G__add_compiledheader("TPieSliceEditor.h");
  G__add_compiledheader("TStyleDialog.h");
  G__add_compiledheader("TStyleManager.h");
  G__add_compiledheader("TStylePreview.h");
  G__add_compiledheader("TTextEditor.h");
  G__cpp_reset_tagtableG__Ged();
}
#include <new>
extern "C" int G__cpp_dllrevG__Ged() { return(30051515); }

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

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

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

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

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

static int G__G__Ged_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGedEditor*) G__getstructoffset())->ActivateEditor((TClass*) 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__Ged_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGedEditor*) G__getstructoffset())->ActivateEditors((TList*) 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__Ged_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGedEditor*) G__getstructoffset())->ExcludeClassEditor((TClass*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGedEditor*) G__getstructoffset())->ExcludeClassEditor((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Ged_251_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGedFrame*) G__getstructoffset())->AddExtraTab((TGedFrame::TGedSubFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


/* TFunctionParametersDialog */
static int G__G__Ged_293_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFunctionParametersDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFunctionParametersDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TFunctionParametersDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGedPopup */
static int G__G__Ged_310_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGedPopup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGedPopup(
(TGWindow*) 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) TGedPopup(
(TGWindow*) 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 TGedPopup(
(TGWindow*) 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) TGedPopup(
(TGWindow*) 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 TGedPopup(
(TGWindow*) 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) TGedPopup(
(TGWindow*) 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;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedPopup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_310_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGedPopup*) 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__Ged_310_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGedPopup*) G__getstructoffset())->EndPopup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Ged_311_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGedPatternFrame::SetFillStyle((TGGC*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Ged_320_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1Editor*) G__getstructoffset())->PaintBox3D((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Ged_330_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPieEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_330_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_330_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPieEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPieEditor G__TTPieEditor;
static int G__G__Ged_330_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[] (TPieEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPieEditor*) (soff+(sizeof(TPieEditor)*i)))->~G__TTPieEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPieEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPieEditor*) (soff))->~G__TTPieEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPieSliceEditor */
static int G__G__Ged_332_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPieSliceEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPieSliceEditor(
(TGWindow*) 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) TPieSliceEditor(
(TGWindow*) 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 TPieSliceEditor(
(TGWindow*) 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) TPieSliceEditor(
(TGWindow*) 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 TPieSliceEditor(
(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) TPieSliceEditor(
(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 TPieSliceEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TPieSliceEditor((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 TPieSliceEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TPieSliceEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TPieSliceEditor[n];
       } else {
         p = new((void*) gvp) TPieSliceEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TPieSliceEditor;
       } else {
         p = new((void*) gvp) TPieSliceEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSliceEditor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSliceEditor*) G__getstructoffset())->DoValue();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSliceEditor*) G__getstructoffset())->DoOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPieSliceEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieSliceEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPieSliceEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPieSliceEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSliceEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieSliceEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPieSliceEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieSliceEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_332_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPieSliceEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPieSliceEditor G__TTPieSliceEditor;
static int G__G__Ged_332_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[] (TPieSliceEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPieSliceEditor*) (soff+(sizeof(TPieSliceEditor)*i)))->~G__TTPieSliceEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPieSliceEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPieSliceEditor*) (soff))->~G__TTPieSliceEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStyleManager */
static int G__G__Ged_334_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStyleManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStyleManager((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TStyleManager((TGWindow*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TStyleManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStyleManager::Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStyleManager::Terminate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TStyleManager*& obj = TStyleManager::GetSM();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->SetCurSelStyle((TStyle*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->SetLastChoice((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoMenu((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoImportMacro((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoListSelect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoRealTime((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoPreview((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoPreviewClosed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoMakeDefault();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoApplyOnSelect((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoApplyOn();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoMoreLess();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoEditionUpdatePreview();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoChangeTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoChangeAxisTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStyleManager*) G__getstructoffset())->BuildList((TStyle*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStyleManager*) G__getstructoffset())->BuildList();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoSelectNoCanvas();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->DoSelectCanvas((TVirtualPad*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFillColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFillStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHatchesLineWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHatchesSpacing();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModMarkerColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModMarkerStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModMarkerSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModScreenFactor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLineColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLineWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLineStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLineStyleEdit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTextColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTextSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTextSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTextFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTextAlign();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTextAngle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasDefX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasDefY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasDefW();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasDefH();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasBorderMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModCanvasBorderSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptDateBool();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModAttDateTextColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModAttDateTextSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModAttDateTextSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptDateFormat();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModAttDateTextFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModAttDateTextAngle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModAttDateTextAlign();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModDateX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModDateY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadTopMargin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadBottomMargin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadLeftMargin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadRightMargin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadBorderMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadBorderSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadTickX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadTickY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadGridX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPadGridY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModGridColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModGridWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModGridStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHistFillColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHistFillStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHistLineColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHistLineWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHistLineStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModBarWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModBarOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHistMinimumZero();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPaintTextFormat();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModNumberContours();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLegoInnerR();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameFillColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameFillStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameLineColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameLineWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameLineStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPaletteEdit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameBorderMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFrameBorderSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFuncColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFuncWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFuncStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModDrawBorder();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModEndErrorSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModErrorX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTimeOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStripDecimals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModApplyOnXYZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXTitleSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXTitleSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXTitleColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXTitleOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXTitleFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXLabelSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXLabelSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXLabelColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXLabelOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXLabelFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_213(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXAxisColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXTickLength();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptLogx();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_216(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModXNdivisions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYTitleSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_218(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYTitleSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_219(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYTitleColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_220(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYTitleOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_221(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYTitleFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYLabelSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYLabelSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYLabelColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYLabelOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_226(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYLabelFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYAxisColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_228(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYTickLength();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_229(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptLogy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_230(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModYNdivisions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_231(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZTitleSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_232(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZTitleSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_233(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZTitleColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_234(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZTitleOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_235(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZTitleFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_236(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZLabelSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_237(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZLabelSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_238(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZLabelColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_239(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZLabelOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_240(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZLabelFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_241(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZAxisColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_242(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZTickLength();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_243(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptLogz();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_244(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModZNdivisions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_245(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptTitle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_246(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleFillColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_247(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_248(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleTextColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_249(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleFontSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_250(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleFontSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_251(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_252(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleAlign();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_253(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleBorderSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_254(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_255(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_256(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleW();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_257(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitleH();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_258(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLegendBorderSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_259(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_260(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_261(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_262(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatFontSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_263(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatFontSizeInPixels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_264(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatFont();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_265(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_266(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_267(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatW();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_268(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatH();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_269(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatBorderSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_270(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptStat();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_271(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModStatFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_272(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModOptFit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_273(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModFitFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_274(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModHeaderPS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_275(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModTitlePS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_276(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModColorModelPS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_277(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModLineScalePS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_278(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPaperSizePredef();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_279(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->ModPaperSizeXY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_280(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStyleManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_281(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyleManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_282(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStyleManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_283(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStyleManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_287(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_288(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyleManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_289(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStyleManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_290(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyleManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_334_0_291(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStyleManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStyleManager G__TTStyleManager;
static int G__G__Ged_334_0_292(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[] (TStyleManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStyleManager*) (soff+(sizeof(TStyleManager)*i)))->~G__TTStyleManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStyleManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStyleManager*) (soff))->~G__TTStyleManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStyleDialog */
static int G__G__Ged_335_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStyleDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStyleDialog(
(TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TStyleDialog(
(TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStyleDialog(
(TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TStyleDialog(
(TStyleManager*) G__int(libp->para[0]), (TStyle*) 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__GedLN_TStyleDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleDialog*) G__getstructoffset())->DoCloseWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleDialog*) G__getstructoffset())->DoCancel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleDialog*) G__getstructoffset())->DoOK();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleDialog*) G__getstructoffset())->DoUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStyleDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyleDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStyleDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStyleDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStyleDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyleDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStyleDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStyleDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_335_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStyleDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStyleDialog G__TTStyleDialog;
static int G__G__Ged_335_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[] (TStyleDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStyleDialog*) (soff+(sizeof(TStyleDialog)*i)))->~G__TTStyleDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStyleDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStyleDialog*) (soff))->~G__TTStyleDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStylePreview */
static int G__G__Ged_352_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStylePreview* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStylePreview(
(TGWindow*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
, (TVirtualPad*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TStylePreview(
(TGWindow*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
, (TVirtualPad*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TStylePreview));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStylePreview*) G__getstructoffset())->Update((TStyle*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStylePreview*) G__getstructoffset())->MapTheWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TStylePreview*) G__getstructoffset())->GetMainCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStylePreview::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStylePreview::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStylePreview::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStylePreview::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStylePreview*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStylePreview::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStylePreview::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStylePreview::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_352_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStylePreview::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStylePreview G__TTStylePreview;
static int G__G__Ged_352_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[] (TStylePreview*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStylePreview*) (soff+(sizeof(TStylePreview)*i)))->~G__TTStylePreview();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStylePreview*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStylePreview*) (soff))->~G__TTStylePreview();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTextEditor */
static int G__G__Ged_355_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTextEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTextEditor(
(TGWindow*) 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) TTextEditor(
(TGWindow*) 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 TTextEditor(
(TGWindow*) 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) TTextEditor(
(TGWindow*) 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 TTextEditor(
(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) TTextEditor(
(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 TTextEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTextEditor((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 TTextEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TTextEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TTextEditor[n];
       } else {
         p = new((void*) gvp) TTextEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TTextEditor;
       } else {
         p = new((void*) gvp) TTextEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TTextEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTextEditor*) G__getstructoffset())->DoAngle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTextEditor*) G__getstructoffset())->DoSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTextEditor*) G__getstructoffset())->DoText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTextEditor*) G__getstructoffset())->DoXpos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTextEditor*) G__getstructoffset())->DoYpos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTextEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTextEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTextEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTextEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTextEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTextEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTextEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTextEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Ged_355_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTextEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTextEditor G__TTTextEditor;
static int G__G__Ged_355_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[] (TTextEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTextEditor*) (soff+(sizeof(TTextEditor)*i)))->~G__TTTextEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTextEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTextEditor*) (soff))->~G__TTTextEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TGedEditor */

/* TGedFrame */

/* TGedNameFrame */

/* TArrowEditor */

/* TGedPatternSelect */

/* TAttFillEditor */

/* TAttLineEditor */

/* TGedMarkerSelect */

/* TAttMarkerEditor */

/* TAttTextEditor */

/* TAxisEditor */

/* TCurlyArcEditor */

/* TCurlyLineEditor */

/* TF1Editor */

/* TFrameEditor */

/* TFunctionParametersDialog */

/* TGedPopup */

/* TGedPatternFrame */

/* TGedPatternSelector */

/* TGedPatternPopup */

/* TGedSelect */

/* TGedMarkerPopup */

/* TGraphEditor */

/* TH1Editor */

/* TH2Editor */

/* TLineEditor */

/* TPadEditor */

/* TPaveStatsEditor */

/* TPieEditor */

/* TPieSliceEditor */

/* TStyleManager */

/* TStyleDialog */

/* TStylePreview */

/* TTextEditor */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Ged {
 public:
  G__Sizep2memfuncG__Ged(): p(&G__Sizep2memfuncG__Ged::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Ged::*p)();
};

size_t G__get_sizep2memfuncG__Ged()
{
  G__Sizep2memfuncG__Ged 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__Ged() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedEditor))) {
     TGedEditor *G__Lderived;
     G__Lderived=(TGedEditor*)0x1000;
     {
       TVirtualPadEditor *G__Lpbase=(TVirtualPadEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TVirtualPadEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedFrame))) {
     TGedFrame *G__Lderived;
     G__Lderived=(TGedFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame))) {
     TGedNameFrame *G__Lderived;
     G__Lderived=(TGedNameFrame*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor))) {
     TArrowEditor *G__Lderived;
     G__Lderived=(TArrowEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect))) {
     TGedPatternSelect *G__Lderived;
     G__Lderived=(TGedPatternSelect*)0x1000;
     {
       TGedSelect *G__Lpbase=(TGedSelect*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGedSelect),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor))) {
     TAttFillEditor *G__Lderived;
     G__Lderived=(TAttFillEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor))) {
     TAttLineEditor *G__Lderived;
     G__Lderived=(TAttLineEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect))) {
     TGedMarkerSelect *G__Lderived;
     G__Lderived=(TGedMarkerSelect*)0x1000;
     {
       TGedSelect *G__Lpbase=(TGedSelect*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGedSelect),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor))) {
     TAttMarkerEditor *G__Lderived;
     G__Lderived=(TAttMarkerEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor))) {
     TAttTextEditor *G__Lderived;
     G__Lderived=(TAttTextEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton))) {
     TGCheckButton *G__Lderived;
     G__Lderived=(TGCheckButton*)0x1000;
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor))) {
     TAxisEditor *G__Lderived;
     G__Lderived=(TAxisEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor))) {
     TCurlyArcEditor *G__Lderived;
     G__Lderived=(TCurlyArcEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor))) {
     TCurlyLineEditor *G__Lderived;
     G__Lderived=(TCurlyLineEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TF1Editor))) {
     TF1Editor *G__Lderived;
     G__Lderived=(TF1Editor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor))) {
     TFrameEditor *G__Lderived;
     G__Lderived=(TFrameEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog))) {
     TFunctionParametersDialog *G__Lderived;
     G__Lderived=(TFunctionParametersDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGButton))) {
     TGButton *G__Lderived;
     G__Lderived=(TGButton*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPopup))) {
     TGedPopup *G__Lderived;
     G__Lderived=(TGedPopup*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame))) {
     TGedPatternFrame *G__Lderived;
     G__Lderived=(TGedPatternFrame*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector))) {
     TGedPatternSelector *G__Lderived;
     G__Lderived=(TGedPatternSelector*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup))) {
     TGedPatternPopup *G__Lderived;
     G__Lderived=(TGedPatternPopup*)0x1000;
     {
       TGedPopup *G__Lpbase=(TGedPopup*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGedPopup),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedSelect))) {
     TGedSelect *G__Lderived;
     G__Lderived=(TGedSelect*)0x1000;
     {
       TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup))) {
     TGedMarkerPopup *G__Lderived;
     G__Lderived=(TGedMarkerPopup*)0x1000;
     {
       TGedPopup *G__Lpbase=(TGedPopup*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGedPopup),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor))) {
     TGraphEditor *G__Lderived;
     G__Lderived=(TGraphEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TH1Editor))) {
     TH1Editor *G__Lderived;
     G__Lderived=(TH1Editor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TH2Editor))) {
     TH2Editor *G__Lderived;
     G__Lderived=(TH2Editor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TLineEditor))) {
     TLineEditor *G__Lderived;
     G__Lderived=(TLineEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPadEditor))) {
     TPadEditor *G__Lderived;
     G__Lderived=(TPadEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor))) {
     TPaveStatsEditor *G__Lderived;
     G__Lderived=(TPaveStatsEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPieEditor))) {
     TPieEditor *G__Lderived;
     G__Lderived=(TPieEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor))) {
     TPieSliceEditor *G__Lderived;
     G__Lderived=(TPieSliceEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TStyleManager))) {
     TStyleManager *G__Lderived;
     G__Lderived=(TStyleManager*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog))) {
     TStyleDialog *G__Lderived;
     G__Lderived=(TStyleDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TStylePreview))) {
     TStylePreview *G__Lderived;
     G__Lderived=(TStylePreview*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TTextEditor))) {
     TTextEditor *G__Lderived;
     G__Lderived=(TTextEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Ged() {

   /* 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("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 8 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("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Pixel_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixel value",0);
   G__search_typename2("pair<UInt_t,Int_t>",117,G__get_linked_tagnum(&G__G__GedLN_pairlEunsignedsPintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned int,int> >",117,G__get_linked_tagnum(&G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__GedLN_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__GedLN_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__GedLN_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__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TGedEditor */
static void G__setup_memvarTGedEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor));
   { TGedEditor *p; p=(TGedEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TMap),-1,-1,2,"fFrameMap=",0,"global map of available frames");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TMap),-1,-1,2,"fExclMap=",0,"map of excluded editors for selected model");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fGedFrames=",0,"list visible of frames ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCanvas),-1,-1,2,"fCan=",0,"provides scroll bars");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,2,"fTab=",0,"tab widget holding the editor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fCreatedTabs=",0,"list of created tabs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fVisibleTabs=",0,"list ofcurrently used tabs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fTabContainer=",0,"main tab container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TObject),-1,-1,2,"fModel=",0,"selected object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,2,"fPad=",0,"selected pad");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TCanvas),-1,-1,2,"fCanvas=",0,"canvas related to the editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-1,2,"fClass=",0,"class of the selected object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGlobal=",0,"true if editor is global");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedEditor),-1,-2,2,"fgFrameCreator=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedFrame */
static void G__setup_memvarTGedFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame));
   { TGedFrame *p; p=(TGedFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInit=",0,"init flag for setting signals/slots");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedEditor),-1,-1,2,"fGedEditor=",0,"manager of this frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-1,2,"fModelClass=",0,"class corresponding to instantiated GedFrame");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAvoidSignal=",0,"flag for executing slots");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fExtraTabs=",0,"addtional tabs in ged editor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPriority=",0,"location in GedEditor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedNameFrame */
static void G__setup_memvarTGedNameFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame));
   { TGedNameFrame *p; p=(TGedNameFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fLabel=",0,"label of attribute frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f2=",0,"container frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGToolTip),-1,-1,2,"fTip=",0,"tool tip associated with button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrowEditor */
static void G__setup_memvarTArrowEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor));
   { TArrowEditor *p; p=(TArrowEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TArrow),-1,-1,2,"fArrow=",0,"arrow object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fOptionCombo=",0,"arrow shapes combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fAngleEntry=",0,"opening angle entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fSizeEntry=",0,"size entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedPatternSelect */
static void G__setup_memvarTGedPatternSelect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect));
   { TGedPatternSelect *p; p=(TGedPatternSelect*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fPattern=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttFillEditor */
static void G__setup_memvarTAttFillEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor));
   { TAttFillEditor *p; p=(TAttFillEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttFill),-1,-1,2,"fAttFill=",0,"fill attribute object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"fill color widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,2,"fPatternSelect=",0,"fill pattern widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fAlpha=",0,"fill opacity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fAlphaField=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttLineEditor */
static void G__setup_memvarTAttLineEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor));
   { TAttLineEditor *p; p=(TAttLineEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttLine),-1,-1,2,"fAttLine=",0,"line attribute object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,2,"fStyleCombo=",0,"line style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fWidthCombo=",0,"line width combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"line color widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fAlpha=",0,"fill opacity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fAlphaField=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedMarkerSelect */
static void G__setup_memvarTGedMarkerSelect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect));
   { TGedMarkerSelect *p; p=(TGedMarkerSelect*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fMarkerStyle=",0,"marker style");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,2,"fPicture=",0,"image used for popup window");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttMarkerEditor */
static void G__setup_memvarTAttMarkerEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor));
   { TAttMarkerEditor *p; p=(TAttMarkerEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttMarker),-1,-1,2,"fAttMarker=",0,"marker attribute object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fMarkerSize=",0,"marker size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"marker color");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),-1,-1,2,"fMarkerType=",0,"marker type");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSizeForText=",0,"true if \"text\" draw option uses marker size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fAlpha=",0,"fill opacity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fAlphaField=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttTextEditor */
static void G__setup_memvarTAttTextEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor));
   { TAttTextEditor *p; p=(TAttTextEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttText),-1,-1,2,"fAttText=",0,"text attribute object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fTypeCombo=",0,"font style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fSizeCombo=",0,"font size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fAlignCombo=",0,"font aligh combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fAlpha=",0,"fill opacity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fAlphaField=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAxisEditor */
static void G__setup_memvarTAxisEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor));
   { TAxisEditor *p; p=(TAxisEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAxis),-1,-1,2,"fAxis=",0,"axis object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fAxisColor=",0,"color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogAxis=",0,"logarithmic check box    ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fTickLength=",0,"tick length number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fDiv1=",0,"primary axis division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fDiv2=",0,"secondary axis division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fDiv3=",0,"tertiary axis division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fOptimize=",0,"tick optimization check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fTicksBoth=",0,"check box setting ticks on both axis sides");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMoreLog=",0,"more logarithmic labels check box");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTicksFlag=",0,"positive/negative ticks' flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"axis title input field");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fTitleColor=",0,"color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fTitleFont=",0,"title font combo box");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fTitleSize=",0,"title size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fTitleOffset=",0,"title offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fCentered=",0,"check button for centered title");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fRotated=",0,"check button for rotated title");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fLabelColor=",0,"color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fLabelFont=",0,"label font combo box");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLabelPrec=",0,"font precision level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fLabelSize=",0,"label size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fLabelOffset=",0,"label offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fNoExponent=",0,"check box for No exponent choice");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDecimal=",0,"decimal part check box    ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCurlyArcEditor */
static void G__setup_memvarTCurlyArcEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor));
   { TCurlyArcEditor *p; p=(TCurlyArcEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TCurlyArc),-1,-1,2,"fCurlyArc=",0,"CurlyArc object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fRadiusEntry=",0,"radius entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fPhiminEntry=",0,"Phimin entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fPhimaxEntry=",0,"Phimax entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fCenterXEntry=",0,"center x entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fCenterYEntry=",0,"center y entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCurlyLineEditor */
static void G__setup_memvarTCurlyLineEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor));
   { TCurlyLineEditor *p; p=(TCurlyLineEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TCurlyLine),-1,-1,2,"fCurlyLine=",0,"CurlyLineobject");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartXEntry=",0,"start  x entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndXEntry=",0,"end  x entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartYEntry=",0,"start  y entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndYEntry=",0,"end  y entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fAmplitudeEntry=",0,"ampl entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fWaveLengthEntry=",0,"wavelength entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fIsWavy=",0,"toggle wavy / curly");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fStartXFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TF1Editor */
static void G__setup_memvarTF1Editor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor));
   { TF1Editor *p; p=(TF1Editor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TF1),-1,-1,2,"fF1=",0,"selected TF1 object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"function title");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNP=",0,"number of function parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fParLabel=",0,"label for number of parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDrawMode=",0,"immediate function redraw (if selected)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fSetPars=",0,"open 'Set Parameters' dialog");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fNXpoints=",0,"number of points along x-axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSliderX=",0,"slider to set x-axis range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMinX=",0,"contains minimum value of x-axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMaxX=",0,"contains maximum value of x-axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFrameEditor */
static void G__setup_memvarTFrameEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor));
   { TFrameEditor *p; p=(TFrameEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TFrame),-1,-1,2,"fFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode=",0,"set sinken frame border mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode0=",0,"set no border");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode1=",0,"set raised frame border mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fBmodelh=",0,"layout hints for border mode buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fBsize=",0,"set frame border size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFunctionParametersDialog */
static void G__setup_memvarTFunctionParametersDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog));
   { TFunctionParametersDialog *p; p=(TFunctionParametersDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TF1),-1,-1,2,"fFunc=",0,"function passed to this dialog");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,2,"fFpad=",0,"pad where the function is drawn");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNP=",0,"number of function parameters");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmin=",0,"min limits of patameters range");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmax=",0,"max limits of patameters range");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPval=",0,"original patameters' values");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPerr=",0,"original patameters' errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRangexmin=",0,"min limits of patameters range");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRangexmax=",0,"max limits of patameters range");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRXmin=",0,"original min range");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRXmax=",0,"original max range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContNam=",0,"container of parameter names");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContVal=",0,"container of parameter values");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContFix=",0,"container of fix settings");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContSld=",0,"container of sliders");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContMin=",0,"container of min range values");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContMax=",0,"container of max range values");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fParNam=",0,"parameter names");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fParFix=",0,"fix setting check buttons");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fParVal=",0,"parameter values");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fParMin=",0,"min range values");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fParMax=",0,"max range values");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGTripleHSlider),-1,-1,2,"fParSld=",0,"triple sliders");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fUpdate=",0,"Immediate update check button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fReset=",0,"Reset button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fOK=",0,"Cancel button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel button");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasChanges=",0,"kTRUE if function was redrawn;");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fImmediateDraw=",0,"kTRUE if function is updated on run-time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedPopup */
static void G__setup_memvarTGedPopup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup));
   { TGedPopup *p; p=(TGedPopup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGWindow),-1,-1,2,"fMsgWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedPatternFrame */
static void G__setup_memvarTGedPatternFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame));
   { TGedPatternFrame *p; p=(TGedPatternFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGWindow),-1,-1,2,"fMsgWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fPattern=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGGC),-1,-2,2,"fgGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGToolTip),-1,-1,2,"fTip=",0,"tool tip associated with a button");
   G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fTipText[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedPatternSelector */
static void G__setup_memvarTGedPatternSelector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector));
   { TGedPatternSelector *p; p=(TGedPatternSelector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActive=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGWindow),-1,-1,2,"fMsgWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),-1,-1,2,"fCe[27]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedPatternPopup */
static void G__setup_memvarTGedPatternPopup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup));
   { TGedPatternPopup *p; p=(TGedPatternPopup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fCurrentPattern=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedSelect */
static void G__setup_memvarTGedSelect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect));
   { TGedSelect *p; p=(TGedSelect*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGGC),-1,-1,2,"fDrawGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPopup),-1,-1,2,"fPopup=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGedMarkerPopup */
static void G__setup_memvarTGedMarkerPopup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup));
   { TGedMarkerPopup *p; p=(TGedMarkerPopup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fCurrentStyle=",0,"currently selected style");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphEditor */
static void G__setup_memvarTGraphEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor));
   { TGraphEditor *p; p=(TGraphEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fDrawShape=",0,"Shape of the Graph (simple, smooth, bar)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"Contains the title of the graph");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGraph),-1,-1,2,"fGraph=",0,"Graph object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,2,"fgr=",0,"Group the Radiobuttons:");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape=",0,"just draw unconnected points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape0=",0,"set smooth graph curve");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape1=",0,"set simple poly-line between every graph point");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape2=",0,"set graph draw mode to bar chart");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape3=",0,"set graph draw mode to fill area");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fShape1lh=",0,"layout-hints for fShape1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMarkerOnOff=",0,"set Marker visible/unvisible");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fWidthCombo=",0,"Exclusion zone width ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fExSide=",0,"set the exclusion zone side");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1Editor */
static void G__setup_memvarTH1Editor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor));
   { TH1Editor *p; p=(TH1Editor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH1),-1,-1,2,"fHist=",0,"histogram object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSameOpt=",0,"flag for option \"same\"");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBin=",0,"Contains the Binning Widgets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"histogram title input field");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHButtonGroup),-1,-1,2,"fDimGroup=",0,"Radiobuttongroup to change 2D <-> 3D-Plot");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim=",0,"2D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim0=",0,"3D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDimlh=",0,"layout hints for 2D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDim0lh=",0,"layout hints for 3D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fTypeCombo=",0,"histogram type combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fCoordsCombo=",0,"Coordinate System combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fErrorCombo=",0,"Error combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fHistOnOff=",0,"Draw a simple histogram with default options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddMarker=",0,"Draw a Marker on top of each bin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddB=",0,"Draw a Bar Chart");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddBar=",0,"Bar Option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAdd=",0,"Activate more Options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMakeHBar=",0,"Draw Horizontal Bar Chart");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddSimple=",0,"Draw a simple histogram  (==HIST draw option)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarWidth=",0,"Change the Bar Width");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarOffset=",0,"Change the Bar Offset");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fAddCombo=",0,"Add Lines, Bars, Fill");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fPercentCombo=",0,"Percentage of the Bar which is drawn in a different color");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f3=",0,"Contains Histogram Type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f6=",0,"Contains the Add-ComboBox (Style)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f7=",0,"Contains the Marker OnOff CheckBox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f8=",0,"Contains the Bar Chart CheckBox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f9=",0,"Contains the Bar Option CheckBox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f10=",0,"Contains the Bar Option Title");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f11=",0,"Contains the Bar Width/Offset NumberEntries");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f12=",0,"Contains fPercentCombo, fMakeHBar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f15=",0,"Contains outer line CheckBox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinCont=",0,"Contains the Rebin Widgets for case 1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinCont1=",0,"Contains the Rebin Widgets for case 2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinSlider=",0,"Slider to set rebinning integer value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinSlider1=",0,"Slider to set rebinning integer value for ntuple histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinNumberEntry=",0,"Label which shows the rebinned bin number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinNumberEntry1=",0,"Label which shows the rebinned bin number for ntuple histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinOffsetSld=",0,"Add an offset to the origin of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fOffsetNumberEntry=",0,"Shows the offset to the origin of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSlider=",0,"Slider to set x-axis range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMin=",0,"Contains the minimum value of the x-Axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMax=",0,"Contains the maximum value of the x-Axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDelaydraw=",0,"Delayed drawing of the new axis range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept the rebinned histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button to reprobate the rebinned histogram");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMake=",0,"Veto Variable");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMakeB=",0,"avoid execution of Bar Slots");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx1old=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy1old=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx2old=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy2old=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1NDCold[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2NDCold[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3NDCold[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4NDCold[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP5old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP6old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP7old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP8old[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH1),-1,-1,4,"fBinHist=",0,"Cloned histogram for rebin");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOldOffset=",0,"save the old offset of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2Editor */
static void G__setup_memvarTH2Editor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor));
   { TH2Editor *p; p=(TH2Editor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH2),-1,-1,2,"fHist=",0,"histogram object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBin=",0,"Contains the Binning Widgets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fFit=",0,"Contains the Fitting Widgets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"histogram title input field");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fTypeCombo=",0,"histogram type combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fCoordsCombo=",0,"Coordinate System combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fContCombo=",0,"Contour selecting combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fColContLbl=",0,"No. of Contours Label 1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fColContLbl1=",0,"No. of Contours Label 2");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHButtonGroup),-1,-1,2,"fDimGroup=",0,"Radiobuttongroup to change 2D <-> 3D-Plot");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim=",0,"2D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim0=",0,"3D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDimlh=",0,"layout hints for 2D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDim0lh=",0,"layout hints for 3D-Plot RadioButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f6=",0,"Frame that contains the 2D CheckBox DrawOptions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f9=",0,"Frame that contains the 3D CheckBox DrawOptions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f12=",0,"Frame that contains the Bar-Title");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f13=",0,"Frame that contains the Bar Width/Offset NumberEntries");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f38=",0,"Frame that contains the Frame Fill widgets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddError=",0,"CheckBox connected to error bars");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddPalette=",0,"CheckBox connected to Z option (2D)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddPalette1=",0,"CheckBox connected to Z option (3D)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddArr=",0,"CheckBox connected to Arr-Option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddBox=",0,"CheckBox connected to Box-Option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddScat=",0,"CheckBox connected to Scat-Option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddCol=",0,"CheckBox connected to Col-Option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddFB=",0,"Draw front box (or not)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddBB=",0,"Draw back box (or not)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddText=",0,"Draw bin contents as text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fContLevels=",0,"Set number of contour levels");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fContLevels1=",0,"Set number of contour levels");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarWidth=",0,"Set bar width of histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarOffset=",0,"Set bar offset of histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinXCont=",0,"Contains the rebin widgets for case 1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinXSlider=",0,"Slider to set rebinning x integer value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinXNumberEntry=",0,"Label which shows the rebinned bin number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinYSlider=",0,"Slider to set rebinning y integer value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinYNumberEntry=",0,"Label which shows the rebinned bin number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept the rebinned histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button to reprobate the rebinned histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinXCont1=",0,"Contains the X Rebin Widgets for case 2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinXSlider1=",0,"Slider to set x rebinning integer value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinXNumberEntry1=",0,"Label which shows the rebinned x bin number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fXOffsetNumberEntry=",0,"Shows the offset to the x origin of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fXBinOffsetSld=",0,"Add an x-offset to the origin of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinYCont1=",0,"Contains the Y Rebin Widgets for case 2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinYSlider1=",0,"Slider to set y rebinning integer value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinYNumberEntry1=",0,"Label which shows the rebinned y bin number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fYOffsetNumberEntry=",0,"Shows the offset to the y origin of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fYBinOffsetSld=",0,"Add an y-offset to the origin of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSliderX=",0,"Slider to set x-axis range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldXMin=",0,"Contains the minimum value of the x-Axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldXMax=",0,"Contains the maximum value of the x-Axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSliderY=",0,"Slider to set y-axis range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldYMin=",0,"Contains the minimum value of the y-Axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldYMax=",0,"Contains the maximum value of the y-Axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDelaydraw=",0,"Delayed drawing of the new axis range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fFrameColor=",0,"Select the Frame Color");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,2,"fFramePattern=",0,"Select the Frame Pattern Style");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TString),-1,-1,2,"fCutString=",0,"Contais info about graphical cuts (if any)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx1old=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy1old=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx2old=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy2old=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP5oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP6oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP7oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP8oldx[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP5oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP6oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP7oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP8oldy[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH2),-1,-1,4,"fBinHist=",0,"Cloned histogram for rebin");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOldXOffset=",0,"saves the old x offset of the histogram");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOldYOffset=",0,"saves the old y offset of the histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLineEditor */
static void G__setup_memvarTLineEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor));
   { TLineEditor *p; p=(TLineEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TLine),-1,-1,2,"fLine=",0,"line object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartPointX=",0,"start point x coordinate");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartPointY=",0,"start point y coordinate");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndPointX=",0,"end point x coordinate");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndPointY=",0,"end point y coordinate");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fVertical=",0,"set the line vertical");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fHorizontal=",0,"set the line horizontal");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPadEditor */
static void G__setup_memvarTPadEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor));
   { TPadEditor *p; p=(TPadEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPad),-1,-1,2,"fPadPointer=",0,"TPad object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fEditable=",0,"set pad editable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fCrosshair=",0,"set crosshair   ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fFixedAR=",0,"set fixed aspect ratio");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fGridX=",0,"set grid on X");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fGridY=",0,"set grid on Y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogX=",0,"set log scale on X");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogY=",0,"set log scale on Y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogZ=",0,"set log scale on Z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fTickX=",0,"set ticks on X");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fTickY=",0,"set ticks on Y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode=",0,"set sinken pad border mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode0=",0,"set no pad border");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode1=",0,"set raised pad border mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fBmodelh=",0,"layout hints for border mode buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fBsize=",0,"set pad border size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,2,"fBgroup=",0,"button group of border mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPaveStatsEditor */
static void G__setup_memvarTPaveStatsEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor));
   { TPaveStatsEditor *p; p=(TPaveStatsEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPaveStats),-1,-1,2,"fPaveStats=",0,"TPaveStats object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fHistoName=",0,"histo name check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fEntries=",0,"entries' number check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMean=",0,"mean value check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fRMS=",0,"RMS check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fUnderflow=",0,"underflow number check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fOverflow=",0,"overflow number check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fIntegral=",0,"integral of bins check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fSkewness=",0,"skewness check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fKurtosis=",0,"kurtosis check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fStatsErrors=",0,"statistics error check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fNameValues=",0,"parameters' name/values check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fErrors=",0,"error check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fChisquare=",0,"Chisquare check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fProbability=",0,"probability check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPieEditor */
static void G__setup_memvarTPieEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor));
   { TPieEditor *p; p=(TPieEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fDrawShape=",0,"Shape of the Graph (simple, smooth, bar)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"Contains the title of the graph");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPie),-1,-1,2,"fPie=",0,"Pie object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,2,"fgr=",0,"Group the Radiobuttons:");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fLblDirH=",0,"Draw slice's labels horizontal");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fLblDirR=",0,"Draw slice's labels radial to the piechart");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fLblDirT=",0,"Draw slice's labels tangential to the piechart's circle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fShape1lh=",0,"layout-hints for fShape1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fOutlineOnOff=",0,"set piechart outline visible/unvisible");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fIs3D=",0,"set if is enabled the pseudo-3d mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"f3DHeight=",0,"set the 3D tickness");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"f3DAngle=",0,"set the pseudo 3D angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"font color selector");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fTypeCombo=",0,"font style");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fSizeCombo=",0,"font size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPieSliceEditor */
static void G__setup_memvarTPieSliceEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor));
   { TPieSliceEditor *p; p=(TPieSliceEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPieSlice),-1,-1,4,"fPieSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"Slice label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fValue=",0,"Value of the slice");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fOffset=",0,"Grafical offset in the radial direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStyleManager */
static void G__setup_memvarTStyleManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager));
   { TStyleManager *p; p=(TStyleManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyleManager),-1,-2,4,"fgStyleManager=",0,"singleton style manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyle),-1,-1,4,"fCurSelStyle=",0,"current selected style");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLastChoice=",0,"=kTRUE if the user choose OK in the last TStyleDialog");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRealTimePreview=",0,"=kTRUE if auto refreshed preview");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurTabNum=",0,"current opened tab number");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurTabAxisNum=",0,"current opened axis tab number");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSMWidth=",0,"style manager's width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSMHeight=",0,"style manager's height");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStyleChanged=",0,"=kTRUE if the style has been modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMoreAndNotLess=",0,"=kTRUE when editor is open");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSigSlotConnected=",0,"=kTRUE when signal/slots connected");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAllAndNotCurrent=",0,"=kTRUE when apply on 'All canvases'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListFrame=",0,"to avoid memory leak");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListLayout=",0,"to avoid memory leak");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGMenuBar),-1,-1,4,"fMenuBar=",0,"the main window menu bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPopupMenu),-1,-1,4,"fMenuStyle=",0,"the 'Style' popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPopupMenu),-1,-1,4,"fImportCascade=",0,"Cascaded menu 'Import'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPopupMenu),-1,-1,4,"fMenuHelp=",0,"the 'Help' popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGToolBar),-1,-1,4,"fToolBar=",0,"the tool bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarNew=",0,"tool bar 'New' button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarDelete=",0,"tool bar 'Delete' button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarImportCanvas=",0,"tool bar 'Import from canvas' button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarImportMacro=",0,"tool bar 'Import from macro' button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarExport=",0,"tool bar 'Export' button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarHelp=",0,"tool bar 'Help' button");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarNewPic=",0,"tool bar 'New' picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarDeletePic=",0,"tool bar 'Delete' picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarImportCanvasPic=",0,"tool bar 'Import from canvas' picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarImportMacroPic=",0,"tool bar 'Import from macro' picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarExportPic=",0,"tool bar 'Export' picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarHelpPic=",0,"tool bar 'Help' picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHorizontal3DLine),-1,-1,4,"fHorizontal3DLine=",0,"a line under the tool bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fListLabel=",0,"label 'Available Styles:'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fListComboBox=",0,"list of available styles");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFileInfo),-1,-1,4,"fCurMacro=",0,"current macro");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fCurStylabel=",0,"label 'gStyle is set to:'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fCurStyle=",0,"label showing gStyle's name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fCurPadLabel=",0,"label 'Canvas:'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fCurPadTextEntry=",0,"label showing current pad's name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,4,"fCurPad=",0,"current pad");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fCurObjLabel=",0,"label 'Object:'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fCurObjTextEntry=",0,"label showing current object's name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TObject),-1,-1,4,"fCurObj=",0,"current object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPreviewButton=",0,"if checked, preview is visible");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPreviewRealTime=",0,"if checked, real time preview");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStylePreview),-1,-1,4,"fPreviewWindow=",0,"preview");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fMakeDefault=",0,"selected style becom gStyle");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fMakeDefaultPic=",0,"button picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHButtonGroup),-1,-1,4,"fApplyOnGroup=",0,"'Apply on' button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fApplyOnAll=",0,"'Apply on' button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fApplyOnSel=",0,"'Apply on' button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fApplyOnButton=",0,"apply style on object(s)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fMoreLess=",0,"open/close the editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGStatusBar),-1,-1,4,"fStatusBar=",0,"status bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGVerticalFrame),-1,-1,4,"fEditionFrame=",0,"editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,4,"fEditionTab=",0,"editor's tabs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,4,"fHistosTab=",0,"histos' tabs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,4,"fAxisTab=",0,"axis' tabs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHorizontalFrame),-1,-1,4,"fEditionButtonFrame=",0,"editor's buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fEditionHelp=",0,"help button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fEditionUpdatePreview=",0,"update preview button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fEditionReset=",0,"reset button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFillColor=",0,"general fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fFillStyle=",0,"general fill pattern selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fHatchesLineWidth=",0,"general hatches width combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fHatchesSpacing=",0,"general hatches spacing number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fTextColor=",0,"general text color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTextSize=",0,"general text size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fTextSizeInPixels=",0,"general text size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fTextFont=",0,"general text font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fTextAlign=",0,"general text align combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTextAngle=",0,"general text angle number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fLineColor=",0,"general line color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fLineWidth=",0,"general line width combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fLineStyle=",0,"general line style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fLineStyleEdit=",0,"general line style editor open button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fMarkerColor=",0,"general marker color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),-1,-1,4,"fMarkerStyle=",0,"general marker style entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fMarkerSize=",0,"general marker size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fScreenFactor=",0,"general screen factor number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fCanvasColor=",0,"canvas fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefX=",0,"canvas abscissa number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefY=",0,"canvas ordinate number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefW=",0,"canvas width number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefH=",0,"canvas height number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fCanvasBorderMode=",0,"canvas border mode button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fCanvasBorderSize=",0,"canvas border size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptDateBool=",0,"canvas date show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fAttDateTextColor=",0,"canvas date color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fAttDateTextSize=",0,"canvas date size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fAttDateTextSizeInPixels=",0,"canvas date size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fOptDateFormat=",0,"canvas date format text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fAttDateTextFont=",0,"canvas date font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fAttDateTextAngle=",0,"canvas date angle number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fAttDateTextAlign=",0,"canvas date align combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fDateX=",0,"canvas date abscissa number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fDateY=",0,"canvas date ordinate number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadLeftMargin=",0,"pad left margin number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadRightMargin=",0,"pad right margin number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadTopMargin=",0,"pad top margin number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadBottomMargin=",0,"pad bottom margin number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fPadBorderMode=",0,"pad border mode button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fPadBorderSize=",0,"pad border size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fPadColor=",0,"pad fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadTickX=",0,"pad ticks along X show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadTickY=",0,"pad ticks along Y show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadGridX=",0,"pad grid along X show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadGridY=",0,"pad grid along Y show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fGridColor=",0,"pad grid line color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fGridWidth=",0,"pad grid line width combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fGridStyle=",0,"pad grid line style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fHistFillColor=",0,"histograms fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fHistFillStyle=",0,"histograms fill pattern selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fHistLineColor=",0,"histograms fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fHistLineWidth=",0,"histograms line width combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fHistLineStyle=",0,"histograms line style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fBarWidth=",0,"histograms bar width number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fBarOffset=",0,"histograms bar offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fHistMinimumZero=",0,"histograms minimum zero check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fPaintTextFormat=",0,"histograms format text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fNumberContours=",0,"histograms number of contours number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fLegoInnerR=",0,"histograms lego inner radius number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFrameFillColor=",0,"frame fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fFrameFillStyle=",0,"frame fill pattern selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFrameLineColor=",0,"frame line color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fFrameLineWidth=",0,"frame line width combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fFrameLineStyle=",0,"frame line style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fPaletteEdit=",0,"palette editor open button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fFrameBorderMode=",0,"frame border mode button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fFrameBorderSize=",0,"frame border size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFuncColor=",0,"function color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fFuncWidth=",0,"function width number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fFuncStyle=",0,"function line style combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fDrawBorder=",0,"function border show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fEndErrorSize=",0,"end error size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fErrorX=",0,"error along abscissa number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTimeOffsetDate=",0,"axis time offset (mm/dd/yyyy) number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTimeOffsetTime=",0,"axis time offset (hh:mm:ss) number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fStripDecimals=",0,"axis label's decimal part show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fApplyOnXYZ=",0,"axis apply on XYZ text button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXTitleSize=",0,"X axis title size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fXTitleSizeInPixels=",0,"X axis title size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fXTitleColor=",0,"X axis title color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXTitleOffset=",0,"X axis title offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fXTitleFont=",0,"X axis title font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXLabelSize=",0,"X axis label size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fXLabelSizeInPixels=",0,"X axis label size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fXLabelColor=",0,"X axis label color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXLabelOffset=",0,"X axis label offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fXLabelFont=",0,"X axis label font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fXAxisColor=",0,"X axis color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXTickLength=",0,"X axis tick length number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptLogx=",0,"X axis logarithmic scale check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXNdivMain=",0,"X axis primary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXNdivSub=",0,"X axis secondary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXNdivSubSub=",0,"X axis tertiary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fXNdivisionsOptimize=",0,"X axis division optimization check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYTitleSize=",0,"Y axis title size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fYTitleSizeInPixels=",0,"Y axis title size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fYTitleColor=",0,"Y axis title color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYTitleOffset=",0,"Y axis title offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fYTitleFont=",0,"Y axis title font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYLabelSize=",0,"Y axis label size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fYLabelSizeInPixels=",0,"Y axis label size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fYLabelColor=",0,"Y axis label color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYLabelOffset=",0,"Y axis label offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fYLabelFont=",0,"Y axis label font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fYAxisColor=",0,"Y axis color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYTickLength=",0,"Y axis tick length number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptLogy=",0,"Y axis logarithmic scale check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYNdivMain=",0,"Y axis primary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYNdivSub=",0,"Y axis secondary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYNdivSubSub=",0,"Y axis tertiary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fYNdivisionsOptimize=",0,"Y axis division optimization check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZTitleSize=",0,"Z axis title size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fZTitleSizeInPixels=",0,"Z axis title size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fZTitleColor=",0,"Z axis title color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZTitleOffset=",0,"Z axis title offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fZTitleFont=",0,"Z axis title font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZLabelSize=",0,"Z axis label size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fZLabelSizeInPixels=",0,"Z axis label size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fZLabelColor=",0,"Z axis label color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZLabelOffset=",0,"Z axis label offset number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fZLabelFont=",0,"Z axis label font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fZAxisColor=",0,"Z axis color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZTickLength=",0,"Z axis tick length number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptLogz=",0,"Z axis logarithmic scale check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZNdivMain=",0,"Z axis primary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZNdivSub=",0,"Z axis secondary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZNdivSubSub=",0,"Z axis tertiary division number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fZNdivisionsOptimize=",0,"Z axis division optimization check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptTitle=",0,"title show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fTitleColor=",0,"title fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fTitleStyle=",0,"title fill pattern selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fTitleTextColor=",0,"title text color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleFontSize=",0,"title font size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fTitleFontSizeInPixels=",0,"title font size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fTitleFont=",0,"title font combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fTitleAlign=",0,"title align combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fTitleBorderSizeLabel=",0,"label 'Title's'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fTitleBorderSize=",0,"title border size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleX=",0,"title abscissa number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleY=",0,"title ordinate number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleW=",0,"title width number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleH=",0,"title height number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fLegendBorderSizeLabel=",0,"label 'Legend's'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fLegendBorderSize=",0,"legend border size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fStatColor=",0,"stats fill color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fStatStyle=",0,"stats fill pattern selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fStatTextColor=",0,"stats text color selection widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatFontSize=",0,"stats font size number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fStatFontSizeInPixels=",0,"stats font size check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fStatFont=",0,"stats font type combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatX=",0,"stats abscissa number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatY=",0,"stats ordinate number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatW=",0,"stats width number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatH=",0,"stats height number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fStatBorderSizeLabel=",0,"label 'stats' shadow");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fStatBorderSize=",0,"stats border size combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatName=",0,"stats name show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatEntries=",0,"stats entries show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatOverflow=",0,"stats overflow show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatMean=",0,"stats mean show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatUnderflow=",0,"stats underflow show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatRMS=",0,"stats RMS show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatSkewness=",0,"stats Skewness show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatIntegral=",0,"stats integral show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatKurtosis=",0,"stats kurtosis show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatErrors=",0,"stats errors check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fStatFormatLabel=",0,"label 'stats format'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fStatFormat=",0,"stats format text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitValues=",0,"fit values show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitErrors=",0,"fit errors check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitProbability=",0,"fit probability show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitChi=",0,"fit Chi show/hide check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fFitFormatLabel=",0,"label 'fit format'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fFitFormat=",0,"fit format text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fHeaderPS=",0,"ps/pdf header text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fTitlePS=",0,"ps/pdf title text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fColorModelPS=",0,"ps/pdf color model button group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fColorModelPSRGB=",0,"RGB radio button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fColorModelPSCMYK=",0,"CMYB radio button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fLineScalePS=",0,"ps/pdf line scale number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fPaperSizePredef=",0,"ps/pdf paper size combo box");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPaperSizeEnCm=",0,"=kTRUE if the paper size is in cm");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPaperSizeX=",0,"ps/pdf paper size width number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPaperSizeY=",0,"ps/pdf paper size height number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandX=",0,"often used layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXMargin=",0,"often used layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXY=",0,"often used layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXYMargin=",0,"often used layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXCenterYMargin=",0,"often used layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStyleDialog */
static void G__setup_memvarTStyleDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog));
   { TStyleDialog *p; p=(TStyleDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyleManager),-1,-1,4,"fStyleManager=",0,"parent style manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fName=",0,"TStyle name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fNameLabel=",0,"name label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fTitle=",0,"TStyle title text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fTitleLabel=",0,"title label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fWarnLabel=",0,"label for warnings");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fOK=",0,"save button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fCancel=",0,"cancel button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyle),-1,-1,4,"fCurStyle=",0,"style to copy or to rename");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMode=",0,"1=new, 2=rename, 3=import");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,4,"fCurPad=",0,"current pad from which to import");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListFrame=",0,"to avoid memory leak");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListLayout=",0,"to avoid memory leak");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStylePreview */
static void G__setup_memvarTStylePreview(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview));
   { TStylePreview *p; p=(TStylePreview*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TRootEmbeddedCanvas),-1,-1,4,"fEcan=",0,"canvas for preview");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,4,"fPad=",0,"original pad previewed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListLayout=",0,"to avoid memory leak");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTextEditor */
static void G__setup_memvarTTextEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor));
   { TTextEditor *p; p=(TTextEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TText),-1,-1,4,"fEditedText=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fText=",0,"Text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fAngle=",0,"Text's angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fSize=",0,"Text's angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fXpos=",0,"Text's X position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fYpos=",0,"Text's Y position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Ged() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTGedEditor(void) {
   /* TGedEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor));
   G__memfunc_setup("TGedEditor",971,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 1, 1, 4, 0, "u 'TGedEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 1, 1, 1, 4, 0, "u 'TGedEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ConfigureGedFrames",1808,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - objChaged", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNameFrame",1472,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGedFrame), -1, 0, 2, 1, 2, 0, 
"U 'TGWindow' - 10 - parent C - - 10 - tab_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGedEditor",971,G__G__Ged_250_0_5, 105, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 3, 1, 1, 0, 
"U 'TCanvas' - 0 '0' canvas h - 'UInt_t' 0 '175' width "
"h - 'UInt_t' 0 '20' height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintFrameStat",1428,G__G__Ged_250_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Ged_250_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame' - 0 '0' frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReinitWorkspace",1562,G__G__Ged_250_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ActivateEditor",1432,G__G__Ged_250_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 0 - cl g - 'Bool_t' 0 - recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ActivateEditors",1547,G__G__Ged_250_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TList' - 0 - bcl g - 'Bool_t' 0 - recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExcludeClassEditor",1831,G__G__Ged_250_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 0 - cl g - 'Bool_t' 0 'kFALSE' recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertGedFrame",1392,G__G__Ged_250_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTGCanvas",1047,G__G__Ged_250_0_13, 85, G__get_linked_tagnum(&G__G__GedLN_TGCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTab",567,G__G__Ged_250_0_14, 85, G__get_linked_tagnum(&G__G__GedLN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditorTab",1182,G__G__Ged_250_0_15, 85, G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEditorTabInfo",1578,G__G__Ged_250_0_16, 85, G__get_linked_tagnum(&G__G__GedLN_TGedTabInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCanvas",892,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPad",565,G__G__Ged_250_0_18, 85, G__get_linked_tagnum(&G__G__GedLN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetModel",785,G__G__Ged_250_0_19, 85, G__get_linked_tagnum(&G__G__GedLN_TObject), -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("ConnectToCanvas",1513,G__G__Ged_250_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisconnectFromCanvas",2042,G__G__Ged_250_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsGlobal",781,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (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("GlobalClosed",1195,G__G__Ged_250_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCanvas",904,G__G__Ged_250_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobal",893,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GlobalSetModel",1390,G__G__Ged_250_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualPad' - 0 - - U 'TObject' - 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,G__G__Ged_250_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualPad' - 0 - pad U 'TObject' - 0 - obj "
"i - 'Int_t' 0 - event", (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("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("GetFrameCreator",1499,G__G__Ged_250_0_32, 85, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGedEditor* (*)())(&TGedEditor::GetFrameCreator) ), 0);
   G__memfunc_setup("SetFrameCreator",1511,G__G__Ged_250_0_33, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TGedEditor' - 0 - e", (char*)NULL, (void*) G__func2void( (void (*)(TGedEditor*))(&TGedEditor::SetFrameCreator) ), 0);
   G__memfunc_setup("Class",502,G__G__Ged_250_0_34, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_250_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_250_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_250_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_250_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_250_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_250_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_250_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_250_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedEditor", 1097, G__G__Ged_250_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedFrame(void) {
   /* TGedFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TGedFrame), -1, 1, 1, 1, 4, 0, "u 'TGedFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeTitle",896,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Ged_251_0_5, 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("GetModelClass",1287,G__G__Ged_251_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPriority",1154,G__G__Ged_251_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExtraTabs",1198,G__G__Ged_251_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGedEditor",1175,G__G__Ged_251_0_10, 85, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddExtraTab",1060,G__G__Ged_251_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame::TGedSubFrame' - 0 - sf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateEditorTabSubFrame",2279,G__G__Ged_251_0_12, 85, G__get_linked_tagnum(&G__G__GedLN_TGVerticalFrame), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,G__G__Ged_251_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 1);
   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("AcceptModel",1089,G__G__Ged_251_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModelClass",1299,G__G__Ged_251_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - mcl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__Ged_251_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGedEditor",1187,G__G__Ged_251_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedEditor' - 0 - ed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateBaseClassEditors",2428,G__G__Ged_251_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_251_0_20, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_251_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_251_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_251_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_251_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_251_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_251_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_251_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_251_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedFrame", 973, G__G__Ged_251_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedNameFrame(void) {
   /* TGedNameFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame));
   G__memfunc_setup("TGedNameFrame",1232,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame), -1, 0, 1, 1, 4, 0, "u 'TGedNameFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame), -1, 1, 1, 1, 4, 0, "u 'TGedNameFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGedNameFrame",1232,G__G__Ged_253_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '170' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' 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("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("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_253_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedNameFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_253_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedNameFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_253_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedNameFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_253_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedNameFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_253_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_253_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedNameFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_253_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedNameFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_253_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedNameFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_253_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedNameFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedNameFrame", 1358, G__G__Ged_253_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrowEditor(void) {
   /* TArrowEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildOptionComboBox",1922,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShapeEntry",1315,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrowEditor",1222,G__G__Ged_257_0_4, 105, G__get_linked_tagnum(&G__G__GedLN_TArrowEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAngle",666,G__G__Ged_257_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOption",812,G__G__Ged_257_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSize",590,G__G__Ged_257_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_257_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrowEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_257_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrowEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_257_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrowEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_257_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrowEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_257_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_257_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrowEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_257_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrowEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_257_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrowEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_257_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrowEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrowEditor", 1348, G__G__Ged_257_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedPatternSelect(void) {
   /* TGedPatternSelect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGedPatternSelect",1698,G__G__Ged_268_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p s - 'Style_t' 0 - pattern "
"i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPattern",1034,G__G__Ged_268_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 - pattern g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPattern",1022,G__G__Ged_268_0_4, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__GedLN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PatternSelected",1543,G__G__Ged_268_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' pattern", "*SIGNAL*", (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("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("Class",502,G__G__Ged_268_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternSelect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_268_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_268_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternSelect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_268_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternSelect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_268_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_268_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_268_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_268_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_268_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelect::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedPatternSelect", 1824, G__G__Ged_268_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttFillEditor(void) {
   /* TAttFillEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TAttFillEditor",1387,G__G__Ged_270_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFillColor",1081,G__G__Ged_270_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFillAlphaColor",1567,G__G__Ged_270_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFillPattern",1304,G__G__Ged_270_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlpha",665,G__G__Ged_270_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlphaField",1149,G__G__Ged_270_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLiveAlpha",1065,G__G__Ged_270_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurAlpha",1072,G__G__Ged_270_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_270_0_11, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttFillEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_270_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFillEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_270_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttFillEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_270_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttFillEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_270_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_270_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFillEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_270_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttFillEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_270_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFillEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_270_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttFillEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAttFillEditor", 1513, G__G__Ged_270_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttLineEditor(void) {
   /* TAttLineEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TAttLineEditor",1388,G__G__Ged_273_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLineColor",1082,G__G__Ged_273_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLineAlphaColor",1568,G__G__Ged_273_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLineStyle",1100,G__G__Ged_273_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - style", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLineWidth",1083,G__G__Ged_273_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - width", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlpha",665,G__G__Ged_273_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlphaField",1149,G__G__Ged_273_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLiveAlpha",1065,G__G__Ged_273_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurAlpha",1072,G__G__Ged_273_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_273_0_12, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttLineEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_273_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLineEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_273_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttLineEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_273_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttLineEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_273_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_273_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLineEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_273_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttLineEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_273_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLineEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_273_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttLineEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAttLineEditor", 1514, G__G__Ged_273_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedMarkerSelect(void) {
   /* TGedMarkerSelect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGedMarkerSelect",1574,G__G__Ged_274_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p s - 'Style_t' 0 - markerStyle "
"i - 'Int_t' 0 - id", (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("GetMarkerStyle",1427,G__G__Ged_274_0_4, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerStyle",1439,G__G__Ged_274_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - pattern", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarkerSelected",1419,G__G__Ged_274_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' marker", "*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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__GedLN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_274_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedMarkerSelect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_274_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerSelect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_274_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedMarkerSelect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_274_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedMarkerSelect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_274_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_274_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerSelect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_274_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerSelect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_274_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerSelect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_274_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerSelect::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedMarkerSelect", 1700, G__G__Ged_274_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttMarkerEditor(void) {
   /* TAttMarkerEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TAttMarkerEditor",1606,G__G__Ged_275_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMarkerColor",1300,G__G__Ged_275_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMarkerAlphaColor",1786,G__G__Ged_275_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMarkerSize",1200,G__G__Ged_275_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMarkerStyle",1318,G__G__Ged_275_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - style", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlpha",665,G__G__Ged_275_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlphaField",1149,G__G__Ged_275_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLiveAlpha",1065,G__G__Ged_275_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurAlpha",1072,G__G__Ged_275_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_275_0_12, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttMarkerEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_275_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarkerEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_275_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttMarkerEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_275_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttMarkerEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_275_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_275_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarkerEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_275_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttMarkerEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_275_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarkerEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_275_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttMarkerEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAttMarkerEditor", 1732, G__G__Ged_275_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttTextEditor(void) {
   /* TAttTextEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildFontSizeComboBox",2107,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildTextAlignComboBox",2201,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAttTextEditor",1417,G__G__Ged_277_0_4, 105, G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(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("DoTextAlphaColor",1597,G__G__Ged_277_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlpha",665,G__G__Ged_277_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAlphaField",1149,G__G__Ged_277_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLiveAlpha",1065,G__G__Ged_277_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurAlpha",1072,G__G__Ged_277_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTextColor",1111,G__G__Ged_277_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_277_0_13, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttTextEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_277_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttTextEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_277_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttTextEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_277_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttTextEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_277_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_277_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttTextEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_277_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttTextEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_277_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttTextEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_277_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttTextEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAttTextEditor", 1543, G__G__Ged_277_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAxisEditor(void) {
   /* TAxisEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TAxisEditor",1104,G__G__Ged_281_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAxisEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTickLength",1184,G__G__Ged_281_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAxisColor",1095,G__G__Ged_281_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTicks",689,G__G__Ged_281_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoDivisions",1131,G__G__Ged_281_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLogAxis",874,G__G__Ged_281_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMoreLog",872,G__G__Ged_281_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitleColor",1204,G__G__Ged_281_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitle",693,G__G__Ged_281_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitleSize",1104,G__G__Ged_281_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitleFont",1100,G__G__Ged_281_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitleOffset",1308,G__G__Ged_281_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitleCentered",1503,G__G__Ged_281_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitleRotated",1416,G__G__Ged_281_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLabelColor",1170,G__G__Ged_281_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLabelSize",1070,G__G__Ged_281_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLabelFont",1066,G__G__Ged_281_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLabelOffset",1274,G__G__Ged_281_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoNoExponent",1217,G__G__Ged_281_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoDecimal",866,G__G__Ged_281_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_281_0_23, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAxisEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_281_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxisEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_281_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAxisEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_281_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAxisEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_281_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_281_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxisEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_281_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxisEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_281_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxisEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_281_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxisEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAxisEditor", 1230, G__G__Ged_281_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCurlyArcEditor(void) {
   /* TCurlyArcEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TCurlyArcEditor",1504,G__G__Ged_283_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoRadius",795,G__G__Ged_283_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoPhimin",792,G__G__Ged_283_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoPhimax",794,G__G__Ged_283_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoCenterXY",965,G__G__Ged_283_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_283_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCurlyArcEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_283_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArcEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_283_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCurlyArcEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_283_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCurlyArcEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_283_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_283_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArcEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_283_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyArcEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_283_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArcEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_283_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyArcEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCurlyArcEditor", 1630, G__G__Ged_283_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCurlyLineEditor(void) {
   /* TCurlyLineEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TCurlyLineEditor",1618,G__G__Ged_285_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoStartXY",882,G__G__Ged_285_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoEndXY",635,G__G__Ged_285_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAmplitude",1112,G__G__Ged_285_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoWaveLength",1192,G__G__Ged_285_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoWavy",602,G__G__Ged_285_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_285_0_10, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCurlyLineEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_285_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLineEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_285_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCurlyLineEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_285_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCurlyLineEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_285_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_285_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLineEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_285_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyLineEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_285_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLineEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_285_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyLineEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCurlyLineEditor", 1744, G__G__Ged_285_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTF1Editor(void) {
   /* TF1Editor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "connect signals to slots", (void*) NULL, 1);
   G__memfunc_setup("TF1Editor",818,G__G__Ged_288_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TF1Editor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoParameterSettings",1957,G__G__Ged_288_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoXPoints",904,G__G__Ged_288_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderXMoved",1385,G__G__Ged_288_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderXPressed",1604,G__G__Ged_288_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderXReleased",1683,G__G__Ged_288_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoXRange",760,G__G__Ged_288_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_288_0_11, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF1Editor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_288_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1Editor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_288_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF1Editor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_288_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF1Editor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_288_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_288_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1Editor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_288_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF1Editor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_288_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1Editor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_288_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF1Editor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TF1Editor", 944, G__G__Ged_288_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFrameEditor(void) {
   /* TFrameEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TFrameEditor",1190,G__G__Ged_291_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TFrameEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBorderMode",1174,G__G__Ged_291_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBorderSize",1196,G__G__Ged_291_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_291_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFrameEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_291_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrameEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_291_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFrameEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_291_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFrameEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_291_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_291_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrameEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_291_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFrameEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_291_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrameEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_291_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFrameEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFrameEditor", 1316, G__G__Ged_291_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFunctionParametersDialog(void) {
   /* TFunctionParametersDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog));
   G__memfunc_setup("TFunctionParametersDialog",2558,G__G__Ged_293_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - main "
"U 'TF1' - 0 - func U 'TVirtualPad' - 0 - pad "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax", (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("DoApply",697,G__G__Ged_293_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoCancel",761,G__G__Ged_293_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFix",474,G__G__Ged_293_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOK",333,G__G__Ged_293_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoParMaxLimit",1275,G__G__Ged_293_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoParMinLimit",1273,G__G__Ged_293_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoParValue",979,G__G__Ged_293_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoReset",694,G__G__Ged_293_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSlider",790,G__G__Ged_293_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButtons",1339,G__G__Ged_293_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - update", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RedrawFunction",1451,G__G__Ged_293_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_293_0_14, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFunctionParametersDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_293_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunctionParametersDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_293_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFunctionParametersDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_293_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFunctionParametersDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_293_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_293_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunctionParametersDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_293_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFunctionParametersDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_293_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunctionParametersDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_293_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFunctionParametersDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFunctionParametersDialog", 2684, G__G__Ged_293_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedPopup(void) {
   /* TGedPopup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup));
   G__memfunc_setup("TGedPopup",888,G__G__Ged_310_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPopup), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - m "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"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("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__Ged_310_0_4, 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__Ged_310_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_310_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPopup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_310_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPopup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_310_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPopup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_310_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPopup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_310_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_310_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPopup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_310_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPopup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_310_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPopup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_310_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPopup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedPopup", 1014, G__G__Ged_310_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedPatternFrame(void) {
   /* TGedPatternFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGedPatternFrame",1581,G__G__Ged_311_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - p s - 'Style_t' 0 - pattern "
"i - 'Int_t' 0 '40' width i - 'Int_t' 0 '20' height", (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("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__Ged_311_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPattern",1022,G__G__Ged_311_0_7, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillStyle",1220,G__G__Ged_311_0_8, 121, -1, -1, 0, 2, 3, 1, 0, 
"U 'TGGC' - 0 - gc s - 'Style_t' 0 - fstyle", "set fill style for given GC", (void*) G__func2void( (void (*)(TGGC*, Style_t))(&TGedPatternFrame::SetFillStyle) ), 0);
   G__memfunc_setup("Class",502,G__G__Ged_311_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_311_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_311_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_311_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_311_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_311_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_311_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_311_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_311_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedPatternFrame", 1707, G__G__Ged_311_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedPatternSelector(void) {
   /* TGedPatternSelector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector));
   G__memfunc_setup("TGedPatternSelector",1923,G__G__Ged_312_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - 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__Ged_312_0_3, 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__Ged_312_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_312_0_5, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternSelector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_312_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_312_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternSelector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_312_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternSelector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_312_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_312_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_312_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_312_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_312_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedPatternSelector", 2049, G__G__Ged_312_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedPatternPopup(void) {
   /* TGedPatternPopup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup));
   G__memfunc_setup("TGedPatternPopup",1622,G__G__Ged_313_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - m "
"s - 'Style_t' 0 - pattern", (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("Class",502,G__G__Ged_313_0_3, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternPopup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_313_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternPopup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_313_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternPopup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_313_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternPopup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_313_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_313_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternPopup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_313_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternPopup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_313_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternPopup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_313_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternPopup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedPatternPopup", 1748, G__G__Ged_313_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedSelect(void) {
   /* TGedSelect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect));
   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("TGedSelect",964,G__G__Ged_314_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TGedSelect), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 - p i - 'Int_t' 0 - 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("Enable",583,G__G__Ged_314_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Disable",692,G__G__Ged_314_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPopup",832,G__G__Ged_314_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedPopup' - 0 - p", "popup will be deleted in destructor.", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_314_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedSelect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_314_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedSelect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_314_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedSelect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_314_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedSelect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_314_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_314_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedSelect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_314_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedSelect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_314_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedSelect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_314_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedSelect::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedSelect", 1090, G__G__Ged_314_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGedMarkerPopup(void) {
   /* TGedMarkerPopup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup));
   G__memfunc_setup("TGedMarkerPopup",1498,G__G__Ged_315_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - m "
"s - 'Style_t' 0 - markerStyle", (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("Class",502,G__G__Ged_315_0_3, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedMarkerPopup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_315_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerPopup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_315_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedMarkerPopup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_315_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedMarkerPopup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_315_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_315_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerPopup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_315_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerPopup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_315_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerPopup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_315_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerPopup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGedMarkerPopup", 1624, G__G__Ged_315_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphEditor(void) {
   /* TGraphEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGraphEditor",1197,G__G__Ged_317_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGraphEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoShape",676,G__G__Ged_317_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMarkerOnOff",1261,G__G__Ged_317_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitle",693,G__G__Ged_317_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoGraphLineWidth",1581,G__G__Ged_317_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_317_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_317_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_317_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_317_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_317_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_317_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_317_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_317_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_317_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphEditor", 1323, G__G__Ged_317_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1Editor(void) {
   /* TH1Editor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor));
   G__memfunc_setup("BuildHistTypeComboBox",2115,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Type ComboBox", (void*) NULL, 0);
   G__memfunc_setup("BuildHistCoordsComboBox",2315,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Coordinate ComboBox", (void*) NULL, 0);
   G__memfunc_setup("BuildHistErrorComboBox",2219,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Error ComboBox", (void*) NULL, 0);
   G__memfunc_setup("BuildHistAddComboBox",1962,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Add ComboBox", (void*) NULL, 0);
   G__memfunc_setup("BuildPercentComboBox",2010,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the ComboBox for setting the Bar options bar1,..., bar4", (void*) NULL, 0);
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "connect the signals to the slots", (void*) NULL, 1);
   G__memfunc_setup("CreateBinTab",1156,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Creates the Bin Tab (part of the SetGedEditor)", (void*) NULL, 0);
   G__memfunc_setup("GetHistTypeLabel",1594,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the Histogram Type = String which contains the Histogram Draw Option", (void*) NULL, 0);
   G__memfunc_setup("GetHistCoordsLabel",1794,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the histogram coordinate system (CYL, SPH, PSR, ..)", (void*) NULL, 0);
   G__memfunc_setup("GetHistErrorLabel",1698,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the histogram Error type (E1, .., E4)", (void*) NULL, 0);
   G__memfunc_setup("GetHistAddLabel",1441,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the histogram addon (smooth line, simple line, ..)", (void*) NULL, 0);
   G__memfunc_setup("ChangeErrorCombo",1600,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1Editor",820,G__G__Ged_320_0_13, 105, G__get_linked_tagnum(&G__G__GedLN_TH1Editor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcceptModel",1089,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitle",693,G__G__Ged_320_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddMarker",1054,G__G__Ged_320_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddBar",721,G__G__Ged_320_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddB",510,G__G__Ged_320_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddSimple",1062,G__G__Ged_320_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistSimple",1205,G__G__Ged_320_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistComplex",1315,G__G__Ged_320_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistChanges",1284,G__G__Ged_320_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistView",998,G__G__Ged_320_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBarOffset",1071,G__G__Ged_320_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBarWidth",968,G__G__Ged_320_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoPercent",900,G__G__Ged_320_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHBar",528,G__G__Ged_320_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderMoved",1297,G__G__Ged_320_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderPressed",1516,G__G__Ged_320_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderReleased",1595,G__G__Ged_320_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAxisRange",1077,G__G__Ged_320_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinMoved",967,G__G__Ged_320_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinReleased",1265,G__G__Ged_320_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinPressed",1186,G__G__Ged_320_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinLabel",940,G__G__Ged_320_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinReleased1",1314,G__G__Ged_320_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinMoved1",1016,G__G__Ged_320_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinLabel1",989,G__G__Ged_320_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOffsetMoved",1301,G__G__Ged_320_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - num", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOffsetReleased",1599,G__G__Ged_320_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOffsetPressed",1520,G__G__Ged_320_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinOffset",1075,G__G__Ged_320_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoApply",697,G__G__Ged_320_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoCancel",761,G__G__Ged_320_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintBox3D",924,G__G__Ged_320_0_46, 121, -1, -1, 0, 4, 1, 1, 0, 
"F - 'Float_t' 0 - p1 F - 'Float_t' 0 - p2 "
"F - 'Float_t' 0 - p3 F - 'Float_t' 0 - p4", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dividers",826,G__G__Ged_320_0_47, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_320_0_49, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1Editor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_320_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1Editor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_320_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1Editor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_320_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1Editor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_320_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_320_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1Editor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_320_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1Editor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_320_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1Editor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_320_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1Editor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1Editor", 946, G__G__Ged_320_0_61, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2Editor(void) {
   /* TH2Editor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor));
   G__memfunc_setup("BuildHistTypeComboBox",2115,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildHistCoordsComboBox",2315,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildHistContComboBox",2101,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBinTab",1156,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Creates the Bin Tab (part of the SetGedEditor)", (void*) NULL, 0);
   G__memfunc_setup("PaintBox3D",924,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"F - 'Float_t' 0 - p1 F - 'Float_t' 0 - p2 "
"F - 'Float_t' 0 - p3 F - 'Float_t' 0 - p4", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistTypeLabel",1594,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistCoordsLabel",1794,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistContLabel",1580,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistAdditiveLabel",1986,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCutOptionString",1852,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2Editor",821,G__G__Ged_322_0_12, 105, G__get_linked_tagnum(&G__G__GedLN_TH2Editor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcceptModel",1089,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitle",693,G__G__Ged_322_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistView",998,G__G__Ged_322_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistSimple",1205,G__G__Ged_322_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistComplex",1315,G__G__Ged_322_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoHistChanges",1284,G__G__Ged_322_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddArr",737,G__G__Ged_322_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddBox",741,G__G__Ged_322_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddCol",730,G__G__Ged_322_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddScat",839,G__G__Ged_322_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddText",865,G__G__Ged_322_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddError",966,G__G__Ged_322_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddPalette",1163,G__G__Ged_322_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddFB",580,G__G__Ged_322_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAddBB",576,G__G__Ged_322_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoContLevel",1087,G__G__Ged_322_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoContLevel1",1136,G__G__Ged_322_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBarWidth",968,G__G__Ged_322_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBarOffset",1071,G__G__Ged_322_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinPressed",1186,G__G__Ged_322_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinMoved",967,G__G__Ged_322_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinReleased",1265,G__G__Ged_322_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinLabel",940,G__G__Ged_322_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoApply",697,G__G__Ged_322_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoCancel",761,G__G__Ged_322_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinReleased1",1314,G__G__Ged_322_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinMoved1",1016,G__G__Ged_322_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinLabel1",989,G__G__Ged_322_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOffsetMoved",1301,G__G__Ged_322_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOffsetReleased",1599,G__G__Ged_322_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOffsetPressed",1520,G__G__Ged_322_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBinOffset",1075,G__G__Ged_322_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderXMoved",1385,G__G__Ged_322_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderXPressed",1604,G__G__Ged_322_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderXReleased",1683,G__G__Ged_322_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoXAxisRange",1165,G__G__Ged_322_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderYMoved",1386,G__G__Ged_322_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderYPressed",1605,G__G__Ged_322_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoSliderYReleased",1684,G__G__Ged_322_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoYAxisRange",1166,G__G__Ged_322_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFillColor",1081,G__G__Ged_322_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFillPattern",1304,G__G__Ged_322_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dividers",826,G__G__Ged_322_0_57, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_322_0_59, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2Editor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_322_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Editor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_322_0_61, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2Editor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_322_0_62, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2Editor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_322_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_322_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Editor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_322_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2Editor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_322_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Editor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_322_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2Editor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2Editor", 947, G__G__Ged_322_0_71, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLineEditor(void) {
   /* TLineEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TLineEditor",1091,G__G__Ged_324_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TLineEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoStartPoint",1227,G__G__Ged_324_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoEndPoint",980,G__G__Ged_324_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLineVertical",1397,G__G__Ged_324_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLineHorizontal",1637,G__G__Ged_324_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_324_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLineEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_324_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLineEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_324_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLineEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_324_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLineEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_324_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_324_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLineEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_324_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLineEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_324_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLineEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_324_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLineEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLineEditor", 1217, G__G__Ged_324_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPadEditor(void) {
   /* TPadEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TPadEditor",976,G__G__Ged_326_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TPadEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoEditable",973,G__G__Ged_326_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoCrosshair",1121,G__G__Ged_326_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFixedAspectRatio",1794,G__G__Ged_326_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoGridX",657,G__G__Ged_326_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoGridY",658,G__G__Ged_326_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLogX",557,G__G__Ged_326_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLogY",558,G__G__Ged_326_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoLogZ",559,G__G__Ged_326_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTickX",662,G__G__Ged_326_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTickY",663,G__G__Ged_326_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBorderMode",1174,G__G__Ged_326_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBorderSize",1196,G__G__Ged_326_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_326_0_17, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPadEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_326_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPadEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_326_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPadEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_326_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPadEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_326_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_326_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPadEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_326_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPadEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_326_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPadEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_326_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPadEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPadEditor", 1102, G__G__Ged_326_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPaveStatsEditor(void) {
   /* TPaveStatsEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TPaveStatsEditor",1622,G__G__Ged_328_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoStatOptions",1339,G__G__Ged_328_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFitOptions",1218,G__G__Ged_328_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetValuesON",1081,G__G__Ged_328_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_328_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPaveStatsEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_328_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStatsEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_328_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPaveStatsEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_328_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPaveStatsEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_328_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_328_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStatsEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_328_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveStatsEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_328_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStatsEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_328_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveStatsEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPaveStatsEditor", 1748, G__G__Ged_328_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPieEditor(void) {
   /* TPieEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildFontSizeComboBox",2107,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0, 
"U 'TGFrame' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPieEditor",985,G__G__Ged_330_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TPieEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoShape",676,G__G__Ged_330_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMarkerOnOff",1261,G__G__Ged_330_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitle",693,G__G__Ged_330_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoGraphLineWidth",1581,G__G__Ged_330_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoChange3DAngle",1367,G__G__Ged_330_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTextChange",1182,G__G__Ged_330_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Ged_330_0_12, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPieEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_330_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_330_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPieEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_330_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPieEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_330_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_330_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_330_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_330_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_330_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPieEditor", 1111, G__G__Ged_330_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPieSliceEditor(void) {
   /* TPieSliceEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPieSliceEditor",1481,G__G__Ged_332_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoTitle",693,G__G__Ged_332_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoValue",688,G__G__Ged_332_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOffset",794,G__G__Ged_332_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_332_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPieSliceEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_332_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSliceEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_332_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPieSliceEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_332_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPieSliceEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_332_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_332_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSliceEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_332_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieSliceEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_332_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSliceEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_332_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieSliceEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPieSliceEditor", 1607, G__G__Ged_332_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStyleManager(void) {
   /* TStyleManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager));
   G__memfunc_setup("AddMenus",785,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoNew",477,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDelete",774,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRename",779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoExport",821,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoExit",589,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoHelp",572,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoImportCanvas",1418,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMacro",1094,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToolbar",988,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTopLevelInterface",1989,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - cf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateStatusBar",1532,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateEditor",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - tabNum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConnectAll",995,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisconnectAll",1315,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConnectEditor",1329,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - tabNum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisconnectEditor",1649,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - tabNum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditor",794,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEdition",981,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabGeneral",1577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddGeneralLine",1359,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddGeneralFill",1358,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddGeneralText",1388,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddGeneralMarker",1577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabCanvas",1479,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCanvasFill",1260,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCanvasGeometry",1713,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCanvasBorder",1475,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCanvasDate",1251,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabPad",1152,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPadMargin",1148,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPadBorder",1148,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPadFill",933,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPadTicks",1052,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPadGrid",932,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabHistos",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabHistosHistos",2143,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosHistosFill",1924,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosHistosLine",1925,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosHistosBar",1810,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosHistosContours",2394,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosHistosAxis",1938,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosHistosLegoInnerR",2514,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabHistosFrames",2115,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosFramesFill",1896,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosFramesLine",1897,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosFramesBorder",2111,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabHistosGraphs",2122,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosGraphsLine",1904,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosGraphsBorder",2118,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistosGraphsErrors",2149,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabAxis",1280,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabAxisX",1368,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisXTitle",1272,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisXLine",1150,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisXLabels",1353,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisXDivisions",1710,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabAxisY",1369,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisYTitle",1273,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisYLine",1151,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisYLabels",1354,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisYDivisions",1711,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabAxisZ",1370,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisZTitle",1274,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisZLine",1152,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisZLabels",1355,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAxisZDivisions",1712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabTitle",1389,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTitleFill",1170,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTitleBorderSize",1796,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTitleText",1200,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTitleGeometry",1623,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabStats",1402,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddStatsFill",1183,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddStatsText",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddStatsGeometry",1636,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddStatsStats",1319,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddStatsFit",1083,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTabPsPdf",1352,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPsPdfHeader",1327,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPsPdfTitle",1256,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPsPdfColorModel",1750,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPsPdfPaperSize",1657,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPsPdfLineScale",1622,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTitle",779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddColorEntry",1306,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGColorSelect), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFillStyleEntry",1715,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMarkerStyleEntry",1934,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMarkerSizeEntry",1816,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNumberEntry",1412,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry), -1, 0, 13, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - e1 "
"i - 'Int_t' 0 - e2 i - 'Int_t' 0 - e3 "
"i - 'Int_t' 0 - id C - - 10 - s "
"d - 'Double_t' 0 - init i - 'Int_t' 0 - digits "
"i 'TGNumberFormat::EStyle' - 0 - nfS i 'TGNumberFormat::EAttribute' - 0 - nfA "
"i 'TGNumberFormat::ELimit' - 0 - nfL d - 'Double_t' 0 - min "
"d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLineWidthEntry",1699,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLineStyleEntry",1716,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTextButton",1322,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGTextButton), -1, 0, 3, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f C - - 10 - s "
"i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFontTypeEntry",1620,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTextAlignEntry",1707,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBorderModeEntry",1790,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup), -1, 0, 4, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id1 "
"i - 'Int_t' 0 - id2 i - 'Int_t' 0 - id3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDateFormatEntry",1794,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCheckButton",1379,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGCheckButton), -1, 0, 5, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f C - - 10 - s "
"i - 'Int_t' 0 - id i - 'Int_t' 0 '0' e1 "
"i - 'Int_t' 0 '2' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTextEntry",1216,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGTextEntry), -1, 0, 3, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f C - - 10 - s "
"i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPaperSizeEntry",1710,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0, 
"U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStyleManager",1312,G__G__Ged_334_0_101, 105, G__get_linked_tagnum(&G__G__GedLN_TStyleManager), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Show",417,G__G__Ged_334_0_102, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleManager::Show) ), 0);
   G__memfunc_setup("Terminate",937,G__G__Ged_334_0_103, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleManager::Terminate) ), 0);
   G__memfunc_setup("GetSM",448,G__G__Ged_334_0_104, 85, G__get_linked_tagnum(&G__G__GedLN_TStyleManager), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TStyleManager*& (*)())(&TStyleManager::GetSM) ), 0);
   G__memfunc_setup("Init",404,G__G__Ged_334_0_105, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hide",378,G__G__Ged_334_0_106, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurSelStyle",1419,G__G__Ged_334_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TStyle' - 0 - style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastChoice",1291,G__G__Ged_334_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - choice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMenu",584,G__G__Ged_334_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - menuID", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoImportMacro",1312,G__G__Ged_334_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - create", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoListSelect",1199,G__G__Ged_334_0_111, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoRealTime",966,G__G__Ged_334_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoPreview",917,G__G__Ged_334_0_113, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoPreviewClosed",1519,G__G__Ged_334_0_114, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoMakeDefault",1270,G__G__Ged_334_0_115, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoApplyOnSelect",1494,G__G__Ged_334_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoApplyOn",886,G__G__Ged_334_0_117, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoMoreLess",989,G__G__Ged_334_0_118, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoEditionUpdatePreview",2244,G__G__Ged_334_0_119, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoChangeTab",1040,G__G__Ged_334_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoChangeAxisTab",1445,G__G__Ged_334_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("BuildList",908,G__G__Ged_334_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TStyle' - 0 '0' style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectNoCanvas",1580,G__G__Ged_334_0_123, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoSelectCanvas",1391,G__G__Ged_334_0_124, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualPad' - 0 - pad U 'TObject' - 0 - obj "
"i - 'Int_t' 0 - mouseButton", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 1);
   G__memfunc_setup("ModFillColor",1190,G__G__Ged_334_0_126, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFillStyle",1208,G__G__Ged_334_0_127, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHatchesLineWidth",1896,G__G__Ged_334_0_128, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHatchesSpacing",1701,G__G__Ged_334_0_129, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModMarkerColor",1409,G__G__Ged_334_0_130, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModMarkerStyle",1427,G__G__Ged_334_0_131, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModMarkerSize",1309,G__G__Ged_334_0_132, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModScreenFactor",1503,G__G__Ged_334_0_133, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLineColor",1191,G__G__Ged_334_0_134, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLineWidth",1192,G__G__Ged_334_0_135, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLineStyle",1209,G__G__Ged_334_0_136, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLineStyleEdit",1599,G__G__Ged_334_0_137, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTextColor",1220,G__G__Ged_334_0_138, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTextSize",1120,G__G__Ged_334_0_139, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTextSizeInPixels",1932,G__G__Ged_334_0_140, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTextFont",1116,G__G__Ged_334_0_141, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTextAlign",1200,G__G__Ged_334_0_142, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTextAngle",1196,G__G__Ged_334_0_143, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasColor",1403,G__G__Ged_334_0_144, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasDefX",1251,G__G__Ged_334_0_145, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasDefY",1252,G__G__Ged_334_0_146, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasDefW",1250,G__G__Ged_334_0_147, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasDefH",1235,G__G__Ged_334_0_148, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasBorderMode",1887,G__G__Ged_334_0_149, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModCanvasBorderSize",1909,G__G__Ged_334_0_150, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptDateBool",1373,G__G__Ged_334_0_151, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModAttDateTextColor",1899,G__G__Ged_334_0_152, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModAttDateTextSize",1799,G__G__Ged_334_0_153, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModAttDateTextSizeInPixels",2611,G__G__Ged_334_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptDateFormat",1594,G__G__Ged_334_0_155, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModAttDateTextFont",1795,G__G__Ged_334_0_156, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModAttDateTextAngle",1875,G__G__Ged_334_0_157, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModAttDateTextAlign",1879,G__G__Ged_334_0_158, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModDateX",758,G__G__Ged_334_0_159, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModDateY",759,G__G__Ged_334_0_160, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadTopMargin",1478,G__G__Ged_334_0_161, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadBottomMargin",1800,G__G__Ged_334_0_162, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadLeftMargin",1566,G__G__Ged_334_0_163, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadRightMargin",1681,G__G__Ged_334_0_164, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadBorderMode",1560,G__G__Ged_334_0_165, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadBorderSize",1582,G__G__Ged_334_0_166, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadColor",1076,G__G__Ged_334_0_167, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadTickX",1048,G__G__Ged_334_0_168, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadTickY",1049,G__G__Ged_334_0_169, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadGridX",1043,G__G__Ged_334_0_170, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPadGridY",1044,G__G__Ged_334_0_171, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModGridColor",1189,G__G__Ged_334_0_172, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModGridWidth",1190,G__G__Ged_334_0_173, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModGridStyle",1207,G__G__Ged_334_0_174, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHistFillColor",1598,G__G__Ged_334_0_175, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHistFillStyle",1616,G__G__Ged_334_0_176, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHistLineColor",1599,G__G__Ged_334_0_177, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHistLineWidth",1600,G__G__Ged_334_0_178, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHistLineStyle",1617,G__G__Ged_334_0_179, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModBarWidth",1077,G__G__Ged_334_0_180, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModBarOffset",1180,G__G__Ged_334_0_181, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHistMinimumZero",1844,G__G__Ged_334_0_182, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPaintTextFormat",1834,G__G__Ged_334_0_183, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModNumberContours",1766,G__G__Ged_334_0_184, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLegoInnerR",1269,G__G__Ged_334_0_185, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameFillColor",1681,G__G__Ged_334_0_186, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameFillStyle",1699,G__G__Ged_334_0_187, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameLineColor",1682,G__G__Ged_334_0_188, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameLineWidth",1683,G__G__Ged_334_0_189, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameLineStyle",1700,G__G__Ged_334_0_190, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPaletteEdit",1397,G__G__Ged_334_0_191, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameBorderMode",1774,G__G__Ged_334_0_192, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFrameBorderSize",1796,G__G__Ged_334_0_193, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFuncColor",1195,G__G__Ged_334_0_194, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFuncWidth",1196,G__G__Ged_334_0_195, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFuncStyle",1213,G__G__Ged_334_0_196, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModDrawBorder",1292,G__G__Ged_334_0_197, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModEndErrorSize",1500,G__G__Ged_334_0_198, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModErrorX",898,G__G__Ged_334_0_199, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTimeOffset",1302,G__G__Ged_334_0_200, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStripDecimals",1620,G__G__Ged_334_0_201, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModApplyOnXYZ",1262,G__G__Ged_334_0_202, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXTitleSize",1301,G__G__Ged_334_0_203, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXTitleSizeInPixels",2113,G__G__Ged_334_0_204, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXTitleColor",1401,G__G__Ged_334_0_205, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXTitleOffset",1505,G__G__Ged_334_0_206, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXTitleFont",1297,G__G__Ged_334_0_207, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXLabelSize",1267,G__G__Ged_334_0_208, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXLabelSizeInPixels",2079,G__G__Ged_334_0_209, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXLabelColor",1367,G__G__Ged_334_0_210, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXLabelOffset",1471,G__G__Ged_334_0_211, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXLabelFont",1263,G__G__Ged_334_0_212, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXAxisColor",1292,G__G__Ged_334_0_213, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXTickLength",1381,G__G__Ged_334_0_214, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptLogx",1005,G__G__Ged_334_0_215, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModXNdivisions",1438,G__G__Ged_334_0_216, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYTitleSize",1302,G__G__Ged_334_0_217, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYTitleSizeInPixels",2114,G__G__Ged_334_0_218, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYTitleColor",1402,G__G__Ged_334_0_219, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYTitleOffset",1506,G__G__Ged_334_0_220, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYTitleFont",1298,G__G__Ged_334_0_221, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYLabelSize",1268,G__G__Ged_334_0_222, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYLabelSizeInPixels",2080,G__G__Ged_334_0_223, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYLabelColor",1368,G__G__Ged_334_0_224, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYLabelOffset",1472,G__G__Ged_334_0_225, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYLabelFont",1264,G__G__Ged_334_0_226, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYAxisColor",1293,G__G__Ged_334_0_227, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYTickLength",1382,G__G__Ged_334_0_228, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptLogy",1006,G__G__Ged_334_0_229, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModYNdivisions",1439,G__G__Ged_334_0_230, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZTitleSize",1303,G__G__Ged_334_0_231, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZTitleSizeInPixels",2115,G__G__Ged_334_0_232, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZTitleColor",1403,G__G__Ged_334_0_233, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZTitleOffset",1507,G__G__Ged_334_0_234, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZTitleFont",1299,G__G__Ged_334_0_235, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZLabelSize",1269,G__G__Ged_334_0_236, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZLabelSizeInPixels",2081,G__G__Ged_334_0_237, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZLabelColor",1369,G__G__Ged_334_0_238, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZLabelOffset",1473,G__G__Ged_334_0_239, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZLabelFont",1265,G__G__Ged_334_0_240, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZAxisColor",1294,G__G__Ged_334_0_241, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZTickLength",1383,G__G__Ged_334_0_242, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptLogz",1007,G__G__Ged_334_0_243, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModZNdivisions",1440,G__G__Ged_334_0_244, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptTitle",1109,G__G__Ged_334_0_245, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleFillColor",1704,G__G__Ged_334_0_246, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleStyle",1331,G__G__Ged_334_0_247, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleTextColor",1734,G__G__Ged_334_0_248, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleFontSize",1620,G__G__Ged_334_0_249, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleFontSizeInPixels",2432,G__G__Ged_334_0_250, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleFont",1209,G__G__Ged_334_0_251, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleAlign",1293,G__G__Ged_334_0_252, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleBorderSize",1819,G__G__Ged_334_0_253, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleX",890,G__G__Ged_334_0_254, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleY",891,G__G__Ged_334_0_255, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleW",889,G__G__Ged_334_0_256, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitleH",874,G__G__Ged_334_0_257, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLegendBorderSize",1896,G__G__Ged_334_0_258, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatColor",1211,G__G__Ged_334_0_259, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatStyle",1229,G__G__Ged_334_0_260, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - pattern", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatTextColor",1632,G__G__Ged_334_0_261, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatFontSize",1518,G__G__Ged_334_0_262, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatFontSizeInPixels",2330,G__G__Ged_334_0_263, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatFont",1107,G__G__Ged_334_0_264, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatX",788,G__G__Ged_334_0_265, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatY",789,G__G__Ged_334_0_266, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatW",787,G__G__Ged_334_0_267, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatH",772,G__G__Ged_334_0_268, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatBorderSize",1717,G__G__Ged_334_0_269, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptStat",1007,G__G__Ged_334_0_270, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModStatFormat",1317,G__G__Ged_334_0_271, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sformat", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModOptFit",886,G__G__Ged_334_0_272, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModFitFormat",1196,G__G__Ged_334_0_273, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fitformat", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModHeaderPS",1036,G__G__Ged_334_0_274, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModTitlePS",965,G__G__Ged_334_0_275, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModColorModelPS",1459,G__G__Ged_334_0_276, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModLineScalePS",1331,G__G__Ged_334_0_277, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPaperSizePredef",1801,G__G__Ged_334_0_278, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("ModPaperSizeXY",1380,G__G__Ged_334_0_279, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_334_0_280, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStyleManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_334_0_281, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_334_0_282, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStyleManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_334_0_283, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_334_0_287, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_334_0_288, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_334_0_289, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_334_0_290, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_334_0_291, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStyleManager", 1438, G__G__Ged_334_0_292, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStyleDialog(void) {
   /* TStyleDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog));
   G__memfunc_setup("TStyleDialog",1205,G__G__Ged_335_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TStyleDialog), -1, 0, 4, 1, 1, 0, 
"U 'TStyleManager' - 0 - sm U 'TStyle' - 0 - cur "
"i - 'Int_t' 0 - mode U 'TVirtualPad' - 0 '0' currentPad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCloseWindow",1313,G__G__Ged_335_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoCancel",761,G__G__Ged_335_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoOK",333,G__G__Ged_335_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("DoUpdate",790,G__G__Ged_335_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_335_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStyleDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_335_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_335_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStyleDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_335_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_335_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_335_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_335_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_335_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_335_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStyleDialog", 1331, G__G__Ged_335_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStylePreview(void) {
   /* TStylePreview */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview));
   G__memfunc_setup("TStylePreview",1351,G__G__Ged_352_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TStylePreview), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TStyle' - 0 - style "
"U 'TVirtualPad' - 0 - currentPad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Ged_352_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TStyle' - 0 - style U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MapTheWindow",1207,G__G__Ged_352_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMainCanvas",1281,G__G__Ged_352_0_4, 85, G__get_linked_tagnum(&G__G__GedLN_TCanvas), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_352_0_5, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStylePreview::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_352_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStylePreview::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_352_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStylePreview::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_352_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStylePreview::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_352_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_352_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStylePreview::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_352_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStylePreview::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_352_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStylePreview::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_352_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStylePreview::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStylePreview", 1477, G__G__Ged_352_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTextEditor(void) {
   /* TTextEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TTextEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTextEditor",1120,G__G__Ged_355_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TTextEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoAngle",666,G__G__Ged_355_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSize",590,G__G__Ged_355_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoText",600,G__G__Ged_355_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoXpos",605,G__G__Ged_355_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoYpos",606,G__G__Ged_355_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Ged_355_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTextEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Ged_355_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTextEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Ged_355_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTextEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Ged_355_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTextEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_355_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Ged_355_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTextEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Ged_355_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTextEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Ged_355_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTextEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Ged_355_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTextEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTextEditor", 1246, G__G__Ged_355_0_21, (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__Ged() {
}

/*********************************************************
* 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() {
}

static void G__cpp_setup_global5() {
}

static void G__cpp_setup_global6() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Ged() {
  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() {
}

static void G__cpp_setup_func4() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Ged() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__GedLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__GedLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GedLN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__GedLN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGPicture = { "TGPicture" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGGC = { "TGGC" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttText = { "TAttText" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__GedLN_pairlEunsignedsPintcOintgR = { "pair<unsigned int,int>" , 115 , -1 };
G__linked_taginfo G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR = { "vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >" , 99 , -1 };
G__linked_taginfo G__G__GedLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGDimension = { "TGDimension" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__GedLN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGToolTip = { "TGToolTip" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGTab = { "TGTab" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedEditor = { "TGedEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedFrame = { "TGedFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedFramecLcLTGedSubFrame = { "TGedFrame::TGedSubFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedNameFrame = { "TGedNameFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TArrow = { "TArrow" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TArrowEditor = { "TArrowEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGWidget = { "TGWidget" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGHSlider = { "TGHSlider" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGColorSelect = { "TGColorSelect" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedPatternSelect = { "TGedPatternSelect" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGNumberEntryField = { "TGNumberEntryField" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttFillEditor = { "TAttFillEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGLineStyleComboBox = { "TGLineStyleComboBox" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGLineWidthComboBox = { "TGLineWidthComboBox" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttLineEditor = { "TAttLineEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedMarkerSelect = { "TGedMarkerSelect" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttMarkerEditor = { "TAttMarkerEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGFontTypeComboBox = { "TGFontTypeComboBox" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAttTextEditor = { "TAttTextEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAxis = { "TAxis" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TAxisEditor = { "TAxisEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TCurlyArc = { "TCurlyArc" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TCurlyArcEditor = { "TCurlyArcEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TCurlyLine = { "TCurlyLine" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TCurlyLineEditor = { "TCurlyLineEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGDoubleHSlider = { "TGDoubleHSlider" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TF1Editor = { "TF1Editor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TFrame = { "TFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TFrameEditor = { "TFrameEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGTripleHSlider = { "TGTripleHSlider" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TFunctionParametersDialog = { "TFunctionParametersDialog" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TVirtualPadEditor = { "TVirtualPadEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGCanvas = { "TGCanvas" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedTabInfo = { "TGedTabInfo" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGButtonGroup = { "TGButtonGroup" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedPopup = { "TGedPopup" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedPatternFrame = { "TGedPatternFrame" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedPatternSelector = { "TGedPatternSelector" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedPatternPopup = { "TGedPatternPopup" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedSelect = { "TGedSelect" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGedMarkerPopup = { "TGedMarkerPopup" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGraphEditor = { "TGraphEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGHButtonGroup = { "TGHButtonGroup" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TH1Editor = { "TH1Editor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TH2Editor = { "TH2Editor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TLine = { "TLine" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TLineEditor = { "TLineEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPad = { "TPad" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPadEditor = { "TPadEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPaveStats = { "TPaveStats" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPaveStatsEditor = { "TPaveStatsEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPie = { "TPie" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPieEditor = { "TPieEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPieSlice = { "TPieSlice" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TPieSliceEditor = { "TPieSliceEditor" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TStyle = { "TStyle" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TStyleManager = { "TStyleManager" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TStyleDialog = { "TStyleDialog" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGNumberFormat = { "TGNumberFormat" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGNumberFormatcLcLEStyle = { "TGNumberFormat::EStyle" , 101 , -1 };
G__linked_taginfo G__G__GedLN_TGNumberFormatcLcLEAttribute = { "TGNumberFormat::EAttribute" , 101 , -1 };
G__linked_taginfo G__G__GedLN_TGNumberFormatcLcLELimit = { "TGNumberFormat::ELimit" , 101 , -1 };
G__linked_taginfo G__G__GedLN_TGFileInfo = { "TGFileInfo" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGHorizontal3DLine = { "TGHorizontal3DLine" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGStatusBar = { "TGStatusBar" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TGToolBar = { "TGToolBar" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TStylePreview = { "TStylePreview" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TRootEmbeddedCanvas = { "TRootEmbeddedCanvas" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TText = { "TText" , 99 , -1 };
G__linked_taginfo G__G__GedLN_TTextEditor = { "TTextEditor" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Ged() {
  G__G__GedLN_TClass.tagnum = -1 ;
  G__G__GedLN_TBuffer.tagnum = -1 ;
  G__G__GedLN_TMemberInspector.tagnum = -1 ;
  G__G__GedLN_TObject.tagnum = -1 ;
  G__G__GedLN_TString.tagnum = -1 ;
  G__G__GedLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GedLN_TList.tagnum = -1 ;
  G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GedLN_Event_t.tagnum = -1 ;
  G__G__GedLN_TGObject.tagnum = -1 ;
  G__G__GedLN_TQObject.tagnum = -1 ;
  G__G__GedLN_TGWindow.tagnum = -1 ;
  G__G__GedLN_TGPicture.tagnum = -1 ;
  G__G__GedLN_TGGC.tagnum = -1 ;
  G__G__GedLN_TAttLine.tagnum = -1 ;
  G__G__GedLN_TAttFill.tagnum = -1 ;
  G__G__GedLN_TAttText.tagnum = -1 ;
  G__G__GedLN_TAttMarker.tagnum = -1 ;
  G__G__GedLN_pairlEunsignedsPintcOintgR.tagnum = -1 ;
  G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__GedLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GedLN_TGDimension.tagnum = -1 ;
  G__G__GedLN_TGFrame.tagnum = -1 ;
  G__G__GedLN_TGCompositeFrame.tagnum = -1 ;
  G__G__GedLN_TGLayoutHints.tagnum = -1 ;
  G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__GedLN_TGTextButton.tagnum = -1 ;
  G__G__GedLN_TGVerticalFrame.tagnum = -1 ;
  G__G__GedLN_TGHorizontalFrame.tagnum = -1 ;
  G__G__GedLN_TGMainFrame.tagnum = -1 ;
  G__G__GedLN_TGTransientFrame.tagnum = -1 ;
  G__G__GedLN_TVirtualPad.tagnum = -1 ;
  G__G__GedLN_TCanvas.tagnum = -1 ;
  G__G__GedLN_TGLabel.tagnum = -1 ;
  G__G__GedLN_TGToolTip.tagnum = -1 ;
  G__G__GedLN_TGTab.tagnum = -1 ;
  G__G__GedLN_TGedEditor.tagnum = -1 ;
  G__G__GedLN_TGedFrame.tagnum = -1 ;
  G__G__GedLN_TGedFramecLcLTGedSubFrame.tagnum = -1 ;
  G__G__GedLN_TGedNameFrame.tagnum = -1 ;
  G__G__GedLN_TGComboBox.tagnum = -1 ;
  G__G__GedLN_TGNumberEntry.tagnum = -1 ;
  G__G__GedLN_TArrow.tagnum = -1 ;
  G__G__GedLN_TArrowEditor.tagnum = -1 ;
  G__G__GedLN_TGWidget.tagnum = -1 ;
  G__G__GedLN_TGHSlider.tagnum = -1 ;
  G__G__GedLN_TGColorSelect.tagnum = -1 ;
  G__G__GedLN_TGedPatternSelect.tagnum = -1 ;
  G__G__GedLN_TGNumberEntryField.tagnum = -1 ;
  G__G__GedLN_TAttFillEditor.tagnum = -1 ;
  G__G__GedLN_TGLineStyleComboBox.tagnum = -1 ;
  G__G__GedLN_TGLineWidthComboBox.tagnum = -1 ;
  G__G__GedLN_TAttLineEditor.tagnum = -1 ;
  G__G__GedLN_TGedMarkerSelect.tagnum = -1 ;
  G__G__GedLN_TAttMarkerEditor.tagnum = -1 ;
  G__G__GedLN_TGFontTypeComboBox.tagnum = -1 ;
  G__G__GedLN_TAttTextEditor.tagnum = -1 ;
  G__G__GedLN_TAxis.tagnum = -1 ;
  G__G__GedLN_TGTextEntry.tagnum = -1 ;
  G__G__GedLN_TGCheckButton.tagnum = -1 ;
  G__G__GedLN_TAxisEditor.tagnum = -1 ;
  G__G__GedLN_TCurlyArc.tagnum = -1 ;
  G__G__GedLN_TCurlyArcEditor.tagnum = -1 ;
  G__G__GedLN_TCurlyLine.tagnum = -1 ;
  G__G__GedLN_TCurlyLineEditor.tagnum = -1 ;
  G__G__GedLN_TGDoubleHSlider.tagnum = -1 ;
  G__G__GedLN_TF1.tagnum = -1 ;
  G__G__GedLN_TF1Editor.tagnum = -1 ;
  G__G__GedLN_TGRadioButton.tagnum = -1 ;
  G__G__GedLN_TFrame.tagnum = -1 ;
  G__G__GedLN_TFrameEditor.tagnum = -1 ;
  G__G__GedLN_TGTripleHSlider.tagnum = -1 ;
  G__G__GedLN_TFunctionParametersDialog.tagnum = -1 ;
  G__G__GedLN_TVirtualPadEditor.tagnum = -1 ;
  G__G__GedLN_TMap.tagnum = -1 ;
  G__G__GedLN_TGCanvas.tagnum = -1 ;
  G__G__GedLN_TGedTabInfo.tagnum = -1 ;
  G__G__GedLN_TGButtonGroup.tagnum = -1 ;
  G__G__GedLN_TGPopupMenu.tagnum = -1 ;
  G__G__GedLN_TGButton.tagnum = -1 ;
  G__G__GedLN_TGPictureButton.tagnum = -1 ;
  G__G__GedLN_TGedPopup.tagnum = -1 ;
  G__G__GedLN_TGedPatternFrame.tagnum = -1 ;
  G__G__GedLN_TGedPatternSelector.tagnum = -1 ;
  G__G__GedLN_TGedPatternPopup.tagnum = -1 ;
  G__G__GedLN_TGedSelect.tagnum = -1 ;
  G__G__GedLN_TGedMarkerPopup.tagnum = -1 ;
  G__G__GedLN_TGraph.tagnum = -1 ;
  G__G__GedLN_TGraphEditor.tagnum = -1 ;
  G__G__GedLN_TH1.tagnum = -1 ;
  G__G__GedLN_TGHButtonGroup.tagnum = -1 ;
  G__G__GedLN_TH1Editor.tagnum = -1 ;
  G__G__GedLN_TH2.tagnum = -1 ;
  G__G__GedLN_TH2Editor.tagnum = -1 ;
  G__G__GedLN_TLine.tagnum = -1 ;
  G__G__GedLN_TLineEditor.tagnum = -1 ;
  G__G__GedLN_TPad.tagnum = -1 ;
  G__G__GedLN_TPadEditor.tagnum = -1 ;
  G__G__GedLN_TPaveStats.tagnum = -1 ;
  G__G__GedLN_TPaveStatsEditor.tagnum = -1 ;
  G__G__GedLN_TPie.tagnum = -1 ;
  G__G__GedLN_TPieEditor.tagnum = -1 ;
  G__G__GedLN_TPieSlice.tagnum = -1 ;
  G__G__GedLN_TPieSliceEditor.tagnum = -1 ;
  G__G__GedLN_TStyle.tagnum = -1 ;
  G__G__GedLN_TStyleManager.tagnum = -1 ;
  G__G__GedLN_TStyleDialog.tagnum = -1 ;
  G__G__GedLN_TGNumberFormat.tagnum = -1 ;
  G__G__GedLN_TGNumberFormatcLcLEStyle.tagnum = -1 ;
  G__G__GedLN_TGNumberFormatcLcLEAttribute.tagnum = -1 ;
  G__G__GedLN_TGNumberFormatcLcLELimit.tagnum = -1 ;
  G__G__GedLN_TGFileInfo.tagnum = -1 ;
  G__G__GedLN_TGHorizontal3DLine.tagnum = -1 ;
  G__G__GedLN_TGMenuBar.tagnum = -1 ;
  G__G__GedLN_TGStatusBar.tagnum = -1 ;
  G__G__GedLN_TGToolBar.tagnum = -1 ;
  G__G__GedLN_TStylePreview.tagnum = -1 ;
  G__G__GedLN_TRootEmbeddedCanvas.tagnum = -1 ;
  G__G__GedLN_TText.tagnum = -1 ;
  G__G__GedLN_TTextEditor.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Ged() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__GedLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TString);
   G__get_linked_tagnum_fwd(&G__G__GedLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TList);
   G__get_linked_tagnum_fwd(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGWindow);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGPicture);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGGC);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TAttText);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__GedLN_pairlEunsignedsPintcOintgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGDimension);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGTextButton);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGVerticalFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGHorizontalFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGTransientFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TCanvas);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGLabel);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGToolTip);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGTab);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedEditor),sizeof(TGedEditor),-1,65280,"ROOT graphics editor",G__setup_memvarTGedEditor,G__setup_memfuncTGedEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedFrame),sizeof(TGedFrame),-1,65281,"base editor's frame",G__setup_memvarTGedFrame,G__setup_memfuncTGedFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGedFramecLcLTGedSubFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedNameFrame),sizeof(TGedNameFrame),-1,65280,"frame showing the selected object name",G__setup_memvarTGedNameFrame,G__setup_memfuncTGedNameFrame);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGComboBox);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberEntry);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TArrow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TArrowEditor),sizeof(TArrowEditor),-1,62720,"GUI for editing arrow attributes",G__setup_memvarTArrowEditor,G__setup_memfuncTArrowEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGWidget);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGHSlider);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGColorSelect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternSelect),sizeof(TGedPatternSelect),-1,62464,"pattern selection check-button",G__setup_memvarTGedPatternSelect,G__setup_memfuncTGedPatternSelect);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberEntryField);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttFillEditor),sizeof(TAttFillEditor),-1,62720,"GUI for editing fill attributes",G__setup_memvarTAttFillEditor,G__setup_memfuncTAttFillEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGLineStyleComboBox);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGLineWidthComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttLineEditor),sizeof(TAttLineEditor),-1,62720,"GUI for editing line attributes",G__setup_memvarTAttLineEditor,G__setup_memfuncTAttLineEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedMarkerSelect),sizeof(TGedMarkerSelect),-1,62464,"Marker selection button",G__setup_memvarTGedMarkerSelect,G__setup_memfuncTGedMarkerSelect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttMarkerEditor),sizeof(TAttMarkerEditor),-1,62720,"GUI for editing marker attributes",G__setup_memvarTAttMarkerEditor,G__setup_memfuncTAttMarkerEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGFontTypeComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttTextEditor),sizeof(TAttTextEditor),-1,62720,"GUI for editing text attributes",G__setup_memvarTAttTextEditor,G__setup_memfuncTAttTextEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TAxis);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGTextEntry);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGCheckButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAxisEditor),sizeof(TAxisEditor),-1,62720,"axis editor",G__setup_memvarTAxisEditor,G__setup_memfuncTAxisEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyArc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyArcEditor),sizeof(TCurlyArcEditor),-1,62720,"GUI for editing arrow attributes",G__setup_memvarTCurlyArcEditor,G__setup_memfuncTCurlyArcEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyLineEditor),sizeof(TCurlyLineEditor),-1,62720,"GUI for editing arrow attributes",G__setup_memvarTCurlyLineEditor,G__setup_memfuncTCurlyLineEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGDoubleHSlider);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TF1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TF1Editor),sizeof(TF1Editor),-1,62720,"user interface for TF1 objects",G__setup_memvarTF1Editor,G__setup_memfuncTF1Editor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGRadioButton);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TFrameEditor),sizeof(TFrameEditor),-1,62720,"editor of TFrame objects",G__setup_memvarTFrameEditor,G__setup_memfuncTFrameEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGTripleHSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TFunctionParametersDialog),sizeof(TFunctionParametersDialog),-1,62464,"Function parameters dialog",G__setup_memvarTFunctionParametersDialog,G__setup_memfuncTFunctionParametersDialog);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TVirtualPadEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TMap);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGCanvas);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGedTabInfo);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGButtonGroup);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGPopupMenu);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGButton);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGPictureButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPopup),sizeof(TGedPopup),-1,62464,"popup window",G__setup_memvarTGedPopup,G__setup_memfuncTGedPopup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternFrame),sizeof(TGedPatternFrame),-1,62464,"pattern frame",G__setup_memvarTGedPatternFrame,G__setup_memfuncTGedPatternFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternSelector),sizeof(TGedPatternSelector),-1,62464,"select pattern frame",G__setup_memvarTGedPatternSelector,G__setup_memfuncTGedPatternSelector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternPopup),sizeof(TGedPatternPopup),-1,62464,"Color selector popup",G__setup_memvarTGedPatternPopup,G__setup_memfuncTGedPatternPopup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedSelect),sizeof(TGedSelect),-1,62464,"selection check-button",G__setup_memvarTGedSelect,G__setup_memfuncTGedSelect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedMarkerPopup),sizeof(TGedMarkerPopup),-1,62464,"marker select popup",G__setup_memvarTGedMarkerPopup,G__setup_memfuncTGedMarkerPopup);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGraphEditor),sizeof(TGraphEditor),-1,62720,"graph editor",G__setup_memvarTGraphEditor,G__setup_memfuncTGraphEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TH1);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGHButtonGroup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TH1Editor),sizeof(TH1Editor),-1,62720,"TH1 editor",G__setup_memvarTH1Editor,G__setup_memfuncTH1Editor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TH2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TH2Editor),sizeof(TH2Editor),-1,62720,"TH2 editor",G__setup_memvarTH2Editor,G__setup_memfuncTH2Editor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TLineEditor),sizeof(TLineEditor),-1,62720,"GUI for editing Line attributes",G__setup_memvarTLineEditor,G__setup_memfuncTLineEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TPad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPadEditor),sizeof(TPadEditor),-1,62720,"editor of TPad objects",G__setup_memvarTPadEditor,G__setup_memfuncTPadEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TPaveStats);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPaveStatsEditor),sizeof(TPaveStatsEditor),-1,62720,"GUI for editing TPaveStats",G__setup_memvarTPaveStatsEditor,G__setup_memfuncTPaveStatsEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TPie);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPieEditor),sizeof(TPieEditor),-1,62720,"piechart editor",G__setup_memvarTPieEditor,G__setup_memfuncTPieEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TPieSlice);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPieSliceEditor),sizeof(TPieSliceEditor),-1,62720,"piechart' slice editor",G__setup_memvarTPieSliceEditor,G__setup_memfuncTPieSliceEditor);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TStyle);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TStyleManager),sizeof(TStyleManager),-1,62464,"Graphical User Interface for managing styles",G__setup_memvarTStyleManager,G__setup_memfuncTStyleManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TStyleDialog),sizeof(TStyleDialog),-1,62464,"Dialog box used by the TStyleManager class",G__setup_memvarTStyleDialog,G__setup_memfuncTStyleDialog);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormat);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormatcLcLEStyle);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormatcLcLEAttribute);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormatcLcLELimit);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGFileInfo);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGHorizontal3DLine);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGMenuBar);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGStatusBar);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TGToolBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TStylePreview),sizeof(TStylePreview),-1,62464,"Preview window used by the TStyleManager class",G__setup_memvarTStylePreview,G__setup_memfuncTStylePreview);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TRootEmbeddedCanvas);
   G__get_linked_tagnum_fwd(&G__G__GedLN_TText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TTextEditor),sizeof(TTextEditor),-1,62720,"text editor",G__setup_memvarTTextEditor,G__setup_memfuncTTextEditor);
}
extern "C" void G__cpp_setupG__Ged(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Ged()");
  G__set_cpp_environmentG__Ged();
  G__cpp_setup_tagtableG__Ged();

  G__cpp_setup_inheritanceG__Ged();

  G__cpp_setup_typetableG__Ged();

  G__cpp_setup_memvarG__Ged();

  G__cpp_setup_memfuncG__Ged();
  G__cpp_setup_globalG__Ged();
  G__cpp_setup_funcG__Ged();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Ged();
  return;
}
class G__cpp_setup_initG__Ged {
  public:
    G__cpp_setup_initG__Ged() { G__add_setup_func("G__Ged",(G__incsetup)(&G__cpp_setupG__Ged)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Ged() { G__remove_setup_func("G__Ged"); }
};
G__cpp_setup_initG__Ged G__cpp_setup_initializerG__Ged;