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

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

#define R__DICTIONARY_FILENAME geomdIgeombuilderdIsrcdIG__GeomBuilder
#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__GeomBuilder.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 TGeoTabManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoTabManager(void *p);
   static void deleteArray_TGeoTabManager(void *p);
   static void destruct_TGeoTabManager(void *p);
   static void streamer_TGeoTabManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoGedFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoGedFrame(void *p);
   static void deleteArray_TGeoGedFrame(void *p);
   static void destruct_TGeoGedFrame(void *p);
   static void streamer_TGeoGedFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoVolumeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoVolumeEditor(void *p = 0);
   static void *newArray_TGeoVolumeEditor(Long_t size, void *p);
   static void delete_TGeoVolumeEditor(void *p);
   static void deleteArray_TGeoVolumeEditor(void *p);
   static void destruct_TGeoVolumeEditor(void *p);
   static void streamer_TGeoVolumeEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoVolumeEditor*)
   {
      ::TGeoVolumeEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoVolumeEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoVolumeEditor", ::TGeoVolumeEditor::Class_Version(), "include/TGeoVolumeEditor.h", 48,
                  typeid(::TGeoVolumeEditor), DefineBehavior(ptr, ptr),
                  &::TGeoVolumeEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoVolumeEditor) );
      instance.SetNew(&new_TGeoVolumeEditor);
      instance.SetNewArray(&newArray_TGeoVolumeEditor);
      instance.SetDelete(&delete_TGeoVolumeEditor);
      instance.SetDeleteArray(&deleteArray_TGeoVolumeEditor);
      instance.SetDestructor(&destruct_TGeoVolumeEditor);
      instance.SetStreamerFunc(&streamer_TGeoVolumeEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoVolumeEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoVolumeEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoVolumeEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoBBoxEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoBBoxEditor(void *p = 0);
   static void *newArray_TGeoBBoxEditor(Long_t size, void *p);
   static void delete_TGeoBBoxEditor(void *p);
   static void deleteArray_TGeoBBoxEditor(void *p);
   static void destruct_TGeoBBoxEditor(void *p);
   static void streamer_TGeoBBoxEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoMediumEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoMediumEditor(void *p = 0);
   static void *newArray_TGeoMediumEditor(Long_t size, void *p);
   static void delete_TGeoMediumEditor(void *p);
   static void deleteArray_TGeoMediumEditor(void *p);
   static void destruct_TGeoMediumEditor(void *p);
   static void streamer_TGeoMediumEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoNodeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoNodeEditor(void *p = 0);
   static void *newArray_TGeoNodeEditor(Long_t size, void *p);
   static void delete_TGeoNodeEditor(void *p);
   static void deleteArray_TGeoNodeEditor(void *p);
   static void destruct_TGeoNodeEditor(void *p);
   static void streamer_TGeoNodeEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTranslationEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTranslationEditor(void *p = 0);
   static void *newArray_TGeoTranslationEditor(Long_t size, void *p);
   static void delete_TGeoTranslationEditor(void *p);
   static void deleteArray_TGeoTranslationEditor(void *p);
   static void destruct_TGeoTranslationEditor(void *p);
   static void streamer_TGeoTranslationEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTranslationEditor*)
   {
      ::TGeoTranslationEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTranslationEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTranslationEditor", ::TGeoTranslationEditor::Class_Version(), "include/TGeoMatrixEditor.h", 41,
                  typeid(::TGeoTranslationEditor), DefineBehavior(ptr, ptr),
                  &::TGeoTranslationEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoTranslationEditor) );
      instance.SetNew(&new_TGeoTranslationEditor);
      instance.SetNewArray(&newArray_TGeoTranslationEditor);
      instance.SetDelete(&delete_TGeoTranslationEditor);
      instance.SetDeleteArray(&deleteArray_TGeoTranslationEditor);
      instance.SetDestructor(&destruct_TGeoTranslationEditor);
      instance.SetStreamerFunc(&streamer_TGeoTranslationEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTranslationEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoTranslationEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTranslationEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoRotationEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoRotationEditor(void *p = 0);
   static void *newArray_TGeoRotationEditor(Long_t size, void *p);
   static void delete_TGeoRotationEditor(void *p);
   static void deleteArray_TGeoRotationEditor(void *p);
   static void destruct_TGeoRotationEditor(void *p);
   static void streamer_TGeoRotationEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoRotationEditor*)
   {
      ::TGeoRotationEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoRotationEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoRotationEditor", ::TGeoRotationEditor::Class_Version(), "include/TGeoMatrixEditor.h", 91,
                  typeid(::TGeoRotationEditor), DefineBehavior(ptr, ptr),
                  &::TGeoRotationEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoRotationEditor) );
      instance.SetNew(&new_TGeoRotationEditor);
      instance.SetNewArray(&newArray_TGeoRotationEditor);
      instance.SetDelete(&delete_TGeoRotationEditor);
      instance.SetDeleteArray(&deleteArray_TGeoRotationEditor);
      instance.SetDestructor(&destruct_TGeoRotationEditor);
      instance.SetStreamerFunc(&streamer_TGeoRotationEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoRotationEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoRotationEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoRotationEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoCombiTransEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoCombiTransEditor(void *p = 0);
   static void *newArray_TGeoCombiTransEditor(Long_t size, void *p);
   static void delete_TGeoCombiTransEditor(void *p);
   static void deleteArray_TGeoCombiTransEditor(void *p);
   static void destruct_TGeoCombiTransEditor(void *p);
   static void streamer_TGeoCombiTransEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoCombiTransEditor*)
   {
      ::TGeoCombiTransEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoCombiTransEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCombiTransEditor", ::TGeoCombiTransEditor::Class_Version(), "include/TGeoMatrixEditor.h", 149,
                  typeid(::TGeoCombiTransEditor), DefineBehavior(ptr, ptr),
                  &::TGeoCombiTransEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoCombiTransEditor) );
      instance.SetNew(&new_TGeoCombiTransEditor);
      instance.SetNewArray(&newArray_TGeoCombiTransEditor);
      instance.SetDelete(&delete_TGeoCombiTransEditor);
      instance.SetDeleteArray(&deleteArray_TGeoCombiTransEditor);
      instance.SetDestructor(&destruct_TGeoCombiTransEditor);
      instance.SetStreamerFunc(&streamer_TGeoCombiTransEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCombiTransEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoCombiTransEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoCombiTransEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoManagerEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoManagerEditor(void *p = 0);
   static void *newArray_TGeoManagerEditor(Long_t size, void *p);
   static void delete_TGeoManagerEditor(void *p);
   static void deleteArray_TGeoManagerEditor(void *p);
   static void destruct_TGeoManagerEditor(void *p);
   static void streamer_TGeoManagerEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoManagerEditor*)
   {
      ::TGeoManagerEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoManagerEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoManagerEditor", ::TGeoManagerEditor::Class_Version(), "include/TGeoManagerEditor.h", 48,
                  typeid(::TGeoManagerEditor), DefineBehavior(ptr, ptr),
                  &::TGeoManagerEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoManagerEditor) );
      instance.SetNew(&new_TGeoManagerEditor);
      instance.SetNewArray(&newArray_TGeoManagerEditor);
      instance.SetDelete(&delete_TGeoManagerEditor);
      instance.SetDeleteArray(&deleteArray_TGeoManagerEditor);
      instance.SetDestructor(&destruct_TGeoManagerEditor);
      instance.SetStreamerFunc(&streamer_TGeoManagerEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoManagerEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoManagerEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoManagerEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoTubeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTubeEditor(void *p = 0);
   static void *newArray_TGeoTubeEditor(Long_t size, void *p);
   static void delete_TGeoTubeEditor(void *p);
   static void deleteArray_TGeoTubeEditor(void *p);
   static void destruct_TGeoTubeEditor(void *p);
   static void streamer_TGeoTubeEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTubeSegEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTubeSegEditor(void *p = 0);
   static void *newArray_TGeoTubeSegEditor(Long_t size, void *p);
   static void delete_TGeoTubeSegEditor(void *p);
   static void deleteArray_TGeoTubeSegEditor(void *p);
   static void destruct_TGeoTubeSegEditor(void *p);
   static void streamer_TGeoTubeSegEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTubeSegEditor*)
   {
      ::TGeoTubeSegEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTubeSegEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTubeSegEditor", ::TGeoTubeSegEditor::Class_Version(), "include/TGeoTubeEditor.h", 93,
                  typeid(::TGeoTubeSegEditor), DefineBehavior(ptr, ptr),
                  &::TGeoTubeSegEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoTubeSegEditor) );
      instance.SetNew(&new_TGeoTubeSegEditor);
      instance.SetNewArray(&newArray_TGeoTubeSegEditor);
      instance.SetDelete(&delete_TGeoTubeSegEditor);
      instance.SetDeleteArray(&deleteArray_TGeoTubeSegEditor);
      instance.SetDestructor(&destruct_TGeoTubeSegEditor);
      instance.SetStreamerFunc(&streamer_TGeoTubeSegEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTubeSegEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoTubeSegEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTubeSegEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoCtubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoCtubEditor(void *p = 0);
   static void *newArray_TGeoCtubEditor(Long_t size, void *p);
   static void delete_TGeoCtubEditor(void *p);
   static void deleteArray_TGeoCtubEditor(void *p);
   static void destruct_TGeoCtubEditor(void *p);
   static void streamer_TGeoCtubEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoCtubEditor*)
   {
      ::TGeoCtubEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoCtubEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCtubEditor", ::TGeoCtubEditor::Class_Version(), "include/TGeoTubeEditor.h", 131,
                  typeid(::TGeoCtubEditor), DefineBehavior(ptr, ptr),
                  &::TGeoCtubEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoCtubEditor) );
      instance.SetNew(&new_TGeoCtubEditor);
      instance.SetNewArray(&newArray_TGeoCtubEditor);
      instance.SetDelete(&delete_TGeoCtubEditor);
      instance.SetDeleteArray(&deleteArray_TGeoCtubEditor);
      instance.SetDestructor(&destruct_TGeoCtubEditor);
      instance.SetStreamerFunc(&streamer_TGeoCtubEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCtubEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoCtubEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoCtubEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoConeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoConeEditor(void *p = 0);
   static void *newArray_TGeoConeEditor(Long_t size, void *p);
   static void delete_TGeoConeEditor(void *p);
   static void deleteArray_TGeoConeEditor(void *p);
   static void destruct_TGeoConeEditor(void *p);
   static void streamer_TGeoConeEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoConeSegEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoConeSegEditor(void *p = 0);
   static void *newArray_TGeoConeSegEditor(Long_t size, void *p);
   static void delete_TGeoConeSegEditor(void *p);
   static void deleteArray_TGeoConeSegEditor(void *p);
   static void destruct_TGeoConeSegEditor(void *p);
   static void streamer_TGeoConeSegEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoConeSegEditor*)
   {
      ::TGeoConeSegEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoConeSegEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoConeSegEditor", ::TGeoConeSegEditor::Class_Version(), "include/TGeoConeEditor.h", 99,
                  typeid(::TGeoConeSegEditor), DefineBehavior(ptr, ptr),
                  &::TGeoConeSegEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoConeSegEditor) );
      instance.SetNew(&new_TGeoConeSegEditor);
      instance.SetNewArray(&newArray_TGeoConeSegEditor);
      instance.SetDelete(&delete_TGeoConeSegEditor);
      instance.SetDeleteArray(&deleteArray_TGeoConeSegEditor);
      instance.SetDestructor(&destruct_TGeoConeSegEditor);
      instance.SetStreamerFunc(&streamer_TGeoConeSegEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoConeSegEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoConeSegEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoConeSegEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoTrd1Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTrd1Editor(void *p = 0);
   static void *newArray_TGeoTrd1Editor(Long_t size, void *p);
   static void delete_TGeoTrd1Editor(void *p);
   static void deleteArray_TGeoTrd1Editor(void *p);
   static void destruct_TGeoTrd1Editor(void *p);
   static void streamer_TGeoTrd1Editor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTrd2Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTrd2Editor(void *p = 0);
   static void *newArray_TGeoTrd2Editor(Long_t size, void *p);
   static void delete_TGeoTrd2Editor(void *p);
   static void deleteArray_TGeoTrd2Editor(void *p);
   static void destruct_TGeoTrd2Editor(void *p);
   static void streamer_TGeoTrd2Editor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoMaterialEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoMaterialEditor(void *p = 0);
   static void *newArray_TGeoMaterialEditor(Long_t size, void *p);
   static void delete_TGeoMaterialEditor(void *p);
   static void deleteArray_TGeoMaterialEditor(void *p);
   static void destruct_TGeoMaterialEditor(void *p);
   static void streamer_TGeoMaterialEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoMixtureEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoMixtureEditor(void *p = 0);
   static void *newArray_TGeoMixtureEditor(Long_t size, void *p);
   static void delete_TGeoMixtureEditor(void *p);
   static void deleteArray_TGeoMixtureEditor(void *p);
   static void destruct_TGeoMixtureEditor(void *p);
   static void streamer_TGeoMixtureEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMixtureEditor*)
   {
      ::TGeoMixtureEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMixtureEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoMixtureEditor", ::TGeoMixtureEditor::Class_Version(), "include/TGeoMaterialEditor.h", 103,
                  typeid(::TGeoMixtureEditor), DefineBehavior(ptr, ptr),
                  &::TGeoMixtureEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoMixtureEditor) );
      instance.SetNew(&new_TGeoMixtureEditor);
      instance.SetNewArray(&newArray_TGeoMixtureEditor);
      instance.SetDelete(&delete_TGeoMixtureEditor);
      instance.SetDeleteArray(&deleteArray_TGeoMixtureEditor);
      instance.SetDestructor(&destruct_TGeoMixtureEditor);
      instance.SetStreamerFunc(&streamer_TGeoMixtureEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoMixtureEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoMixtureEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMixtureEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoTreeDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoTreeDialog(void *p);
   static void deleteArray_TGeoTreeDialog(void *p);
   static void destruct_TGeoTreeDialog(void *p);
   static void streamer_TGeoTreeDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTransientPanel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoTransientPanel(void *p);
   static void deleteArray_TGeoTransientPanel(void *p);
   static void destruct_TGeoTransientPanel(void *p);
   static void streamer_TGeoTransientPanel(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoVolumeDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoVolumeDialog(void *p);
   static void deleteArray_TGeoVolumeDialog(void *p);
   static void destruct_TGeoVolumeDialog(void *p);
   static void streamer_TGeoVolumeDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoShapeDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoShapeDialog(void *p);
   static void deleteArray_TGeoShapeDialog(void *p);
   static void destruct_TGeoShapeDialog(void *p);
   static void streamer_TGeoShapeDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoMediumDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoMediumDialog(void *p);
   static void deleteArray_TGeoMediumDialog(void *p);
   static void destruct_TGeoMediumDialog(void *p);
   static void streamer_TGeoMediumDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoMaterialDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoMaterialDialog(void *p);
   static void deleteArray_TGeoMaterialDialog(void *p);
   static void destruct_TGeoMaterialDialog(void *p);
   static void streamer_TGeoMaterialDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoMatrixDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoMatrixDialog(void *p);
   static void deleteArray_TGeoMatrixDialog(void *p);
   static void destruct_TGeoMatrixDialog(void *p);
   static void streamer_TGeoMatrixDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoSphereEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoSphereEditor(void *p = 0);
   static void *newArray_TGeoSphereEditor(Long_t size, void *p);
   static void delete_TGeoSphereEditor(void *p);
   static void deleteArray_TGeoSphereEditor(void *p);
   static void destruct_TGeoSphereEditor(void *p);
   static void streamer_TGeoSphereEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoPconSection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoPconSection(void *p);
   static void deleteArray_TGeoPconSection(void *p);
   static void destruct_TGeoPconSection(void *p);
   static void streamer_TGeoPconSection(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoPconEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPconEditor(void *p = 0);
   static void *newArray_TGeoPconEditor(Long_t size, void *p);
   static void delete_TGeoPconEditor(void *p);
   static void deleteArray_TGeoPconEditor(void *p);
   static void destruct_TGeoPconEditor(void *p);
   static void streamer_TGeoPconEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoParaEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoParaEditor(void *p = 0);
   static void *newArray_TGeoParaEditor(Long_t size, void *p);
   static void delete_TGeoParaEditor(void *p);
   static void deleteArray_TGeoParaEditor(void *p);
   static void destruct_TGeoParaEditor(void *p);
   static void streamer_TGeoParaEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTorusEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTorusEditor(void *p = 0);
   static void *newArray_TGeoTorusEditor(Long_t size, void *p);
   static void delete_TGeoTorusEditor(void *p);
   static void deleteArray_TGeoTorusEditor(void *p);
   static void destruct_TGeoTorusEditor(void *p);
   static void streamer_TGeoTorusEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoEltuEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoEltuEditor(void *p = 0);
   static void *newArray_TGeoEltuEditor(Long_t size, void *p);
   static void delete_TGeoEltuEditor(void *p);
   static void deleteArray_TGeoEltuEditor(void *p);
   static void destruct_TGeoEltuEditor(void *p);
   static void streamer_TGeoEltuEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoHypeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoHypeEditor(void *p = 0);
   static void *newArray_TGeoHypeEditor(Long_t size, void *p);
   static void delete_TGeoHypeEditor(void *p);
   static void deleteArray_TGeoHypeEditor(void *p);
   static void destruct_TGeoHypeEditor(void *p);
   static void streamer_TGeoHypeEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoPgonEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPgonEditor(void *p = 0);
   static void *newArray_TGeoPgonEditor(Long_t size, void *p);
   static void delete_TGeoPgonEditor(void *p);
   static void deleteArray_TGeoPgonEditor(void *p);
   static void destruct_TGeoPgonEditor(void *p);
   static void streamer_TGeoPgonEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTrapEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTrapEditor(void *p = 0);
   static void *newArray_TGeoTrapEditor(Long_t size, void *p);
   static void delete_TGeoTrapEditor(void *p);
   static void deleteArray_TGeoTrapEditor(void *p);
   static void destruct_TGeoTrapEditor(void *p);
   static void streamer_TGeoTrapEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoGtraEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoGtraEditor(void *p = 0);
   static void *newArray_TGeoGtraEditor(Long_t size, void *p);
   static void delete_TGeoGtraEditor(void *p);
   static void deleteArray_TGeoGtraEditor(void *p);
   static void destruct_TGeoGtraEditor(void *p);
   static void streamer_TGeoGtraEditor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoGtraEditor*)
   {
      ::TGeoGtraEditor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoGtraEditor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoGtraEditor", ::TGeoGtraEditor::Class_Version(), "include/TGeoTrapEditor.h", 100,
                  typeid(::TGeoGtraEditor), DefineBehavior(ptr, ptr),
                  &::TGeoGtraEditor::Dictionary, isa_proxy, 0,
                  sizeof(::TGeoGtraEditor) );
      instance.SetNew(&new_TGeoGtraEditor);
      instance.SetNewArray(&newArray_TGeoGtraEditor);
      instance.SetDelete(&delete_TGeoGtraEditor);
      instance.SetDeleteArray(&deleteArray_TGeoGtraEditor);
      instance.SetDestructor(&destruct_TGeoGtraEditor);
      instance.SetStreamerFunc(&streamer_TGeoGtraEditor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoGtraEditor*)
   {
      return GenerateInitInstanceLocal((::TGeoGtraEditor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoGtraEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoVolumeEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoVolumeEditor.
      TClass *R__cl = ::TGeoVolumeEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometry", &fGeometry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsAssembly", &fIsAssembly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsDivided", &fIsDivided);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCategories", &fCategories);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeName", &fVolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedShape", &fSelectedShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelShape", &fLSelShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelShape", &fBSelShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMedium", &fSelectedMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMedium", &fLSelMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMedium", &fBSelMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedVolume", &fSelectedVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelVolume", &fLSelVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelVolume", &fBSelVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMatrix", &fSelectedMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMatrix", &fLSelMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMatrix", &fBSelMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCopyNumber", &fCopyNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddNode", &fAddNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditShape", &fEditShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMedium", &fEditMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeList", &fNodeList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMatrix", &fEditMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRemoveNode", &fRemoveNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBVis[2]", &fBVis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBView[3]", &fBView);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBRaytrace", &fBRaytrace);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBAuto", &fBAuto);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEVisLevel", &fEVisLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyDiv", &fApplyDiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDivName", &fDivName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBDiv[3]", &fBDiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDivFrom", &fEDivFrom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDivStep", &fEDivStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDivN", &fEDivN);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoVolumeEditor(void *p) {
      return  p ? new(p) ::TGeoVolumeEditor : new ::TGeoVolumeEditor;
   }
   static void *newArray_TGeoVolumeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoVolumeEditor[nElements] : new ::TGeoVolumeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoVolumeEditor(void *p) {
      delete ((::TGeoVolumeEditor*)p);
   }
   static void deleteArray_TGeoVolumeEditor(void *p) {
      delete [] ((::TGeoVolumeEditor*)p);
   }
   static void destruct_TGeoVolumeEditor(void *p) {
      typedef ::TGeoVolumeEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoVolumeEditor(TBuffer &buf, void *obj) {
      ((::TGeoVolumeEditor*)obj)->::TGeoVolumeEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoVolumeEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoBBoxEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoBBoxEditor.
      TClass *R__cl = ::TGeoBBoxEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi", &fDxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrigi[3]", fOrigi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxDx", &fBoxDx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxDy", &fBoxDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxDz", &fBoxDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxOx", &fBoxOx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxOy", &fBoxOy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxOz", &fBoxOz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoBBoxEditor(void *p) {
      return  p ? new(p) ::TGeoBBoxEditor : new ::TGeoBBoxEditor;
   }
   static void *newArray_TGeoBBoxEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoBBoxEditor[nElements] : new ::TGeoBBoxEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoBBoxEditor(void *p) {
      delete ((::TGeoBBoxEditor*)p);
   }
   static void deleteArray_TGeoBBoxEditor(void *p) {
      delete [] ((::TGeoBBoxEditor*)p);
   }
   static void destruct_TGeoBBoxEditor(void *p) {
      typedef ::TGeoBBoxEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoBBoxEditor(TBuffer &buf, void *obj) {
      ((::TGeoBBoxEditor*)obj)->::TGeoBBoxEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoBBoxEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTubeEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTubeEditor.
      TClass *R__cl = ::TGeoTubeEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini", &fRmini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi", &fRmaxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTubeEditor(void *p) {
      return  p ? new(p) ::TGeoTubeEditor : new ::TGeoTubeEditor;
   }
   static void *newArray_TGeoTubeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTubeEditor[nElements] : new ::TGeoTubeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTubeEditor(void *p) {
      delete ((::TGeoTubeEditor*)p);
   }
   static void deleteArray_TGeoTubeEditor(void *p) {
      delete [] ((::TGeoTubeEditor*)p);
   }
   static void destruct_TGeoTubeEditor(void *p) {
      typedef ::TGeoTubeEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTubeEditor(TBuffer &buf, void *obj) {
      ((::TGeoTubeEditor*)obj)->::TGeoTubeEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTubeEditor

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

   TGeoTubeEditor::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTubeSegEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTubeSegEditor.
      TClass *R__cl = ::TGeoTubeSegEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmini", &fPmini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmaxi", &fPmaxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSPhi", &fSPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi2", &fEPhi2);
      TGeoTubeEditor::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTubeSegEditor(void *p) {
      return  p ? new(p) ::TGeoTubeSegEditor : new ::TGeoTubeSegEditor;
   }
   static void *newArray_TGeoTubeSegEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTubeSegEditor[nElements] : new ::TGeoTubeSegEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTubeSegEditor(void *p) {
      delete ((::TGeoTubeSegEditor*)p);
   }
   static void deleteArray_TGeoTubeSegEditor(void *p) {
      delete [] ((::TGeoTubeSegEditor*)p);
   }
   static void destruct_TGeoTubeSegEditor(void *p) {
      typedef ::TGeoTubeSegEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTubeSegEditor(TBuffer &buf, void *obj) {
      ((::TGeoTubeSegEditor*)obj)->::TGeoTubeSegEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTubeSegEditor

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

   TGeoTubeSegEditor::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoCtubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoCtubEditor.
      TClass *R__cl = ::TGeoCtubEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThlo", &fThlo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhlo", &fPhlo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThhi", &fThhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhhi", &fPhhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEThlo", &fEThlo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhlo", &fEPhlo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEThhi", &fEThhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhhi", &fEPhhi);
      TGeoTubeSegEditor::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoCtubEditor(void *p) {
      return  p ? new(p) ::TGeoCtubEditor : new ::TGeoCtubEditor;
   }
   static void *newArray_TGeoCtubEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoCtubEditor[nElements] : new ::TGeoCtubEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoCtubEditor(void *p) {
      delete ((::TGeoCtubEditor*)p);
   }
   static void deleteArray_TGeoCtubEditor(void *p) {
      delete [] ((::TGeoCtubEditor*)p);
   }
   static void destruct_TGeoCtubEditor(void *p) {
      typedef ::TGeoCtubEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoCtubEditor(TBuffer &buf, void *obj) {
      ((::TGeoCtubEditor*)obj)->::TGeoCtubEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoCtubEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoEltuEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoEltuEditor.
      TClass *R__cl = ::TGeoEltuEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAi", &fAi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBi", &fBi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEA", &fEA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEB", &fEB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoEltuEditor(void *p) {
      return  p ? new(p) ::TGeoEltuEditor : new ::TGeoEltuEditor;
   }
   static void *newArray_TGeoEltuEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoEltuEditor[nElements] : new ::TGeoEltuEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoEltuEditor(void *p) {
      delete ((::TGeoEltuEditor*)p);
   }
   static void deleteArray_TGeoEltuEditor(void *p) {
      delete [] ((::TGeoEltuEditor*)p);
   }
   static void destruct_TGeoEltuEditor(void *p) {
      typedef ::TGeoEltuEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoEltuEditor(TBuffer &buf, void *obj) {
      ((::TGeoEltuEditor*)obj)->::TGeoEltuEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoEltuEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoHypeEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoHypeEditor.
      TClass *R__cl = ::TGeoHypeEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRini", &fRini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRouti", &fRouti);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStIni", &fStIni);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStOuti", &fStOuti);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERin", &fERin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERout", &fERout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEStIn", &fEStIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEStOut", &fEStOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoHypeEditor(void *p) {
      return  p ? new(p) ::TGeoHypeEditor : new ::TGeoHypeEditor;
   }
   static void *newArray_TGeoHypeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoHypeEditor[nElements] : new ::TGeoHypeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoHypeEditor(void *p) {
      delete ((::TGeoHypeEditor*)p);
   }
   static void deleteArray_TGeoHypeEditor(void *p) {
      delete [] ((::TGeoHypeEditor*)p);
   }
   static void destruct_TGeoHypeEditor(void *p) {
      typedef ::TGeoHypeEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoHypeEditor(TBuffer &buf, void *obj) {
      ((::TGeoHypeEditor*)obj)->::TGeoHypeEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoHypeEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoConeEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoConeEditor.
      TClass *R__cl = ::TGeoConeEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini1", &fRmini1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi1", &fRmaxi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini2", &fRmini2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi2", &fRmaxi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin1", &fERmin1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin2", &fERmin2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax1", &fERmax1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax2", &fERmax2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoConeEditor(void *p) {
      return  p ? new(p) ::TGeoConeEditor : new ::TGeoConeEditor;
   }
   static void *newArray_TGeoConeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoConeEditor[nElements] : new ::TGeoConeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoConeEditor(void *p) {
      delete ((::TGeoConeEditor*)p);
   }
   static void deleteArray_TGeoConeEditor(void *p) {
      delete [] ((::TGeoConeEditor*)p);
   }
   static void destruct_TGeoConeEditor(void *p) {
      typedef ::TGeoConeEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoConeEditor(TBuffer &buf, void *obj) {
      ((::TGeoConeEditor*)obj)->::TGeoConeEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoConeEditor

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

   TGeoConeEditor::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoConeSegEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoConeSegEditor.
      TClass *R__cl = ::TGeoConeSegEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmini", &fPmini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmaxi", &fPmaxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSPhi", &fSPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi2", &fEPhi2);
      TGeoConeEditor::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoConeSegEditor(void *p) {
      return  p ? new(p) ::TGeoConeSegEditor : new ::TGeoConeSegEditor;
   }
   static void *newArray_TGeoConeSegEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoConeSegEditor[nElements] : new ::TGeoConeSegEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoConeSegEditor(void *p) {
      delete ((::TGeoConeSegEditor*)p);
   }
   static void deleteArray_TGeoConeSegEditor(void *p) {
      delete [] ((::TGeoConeSegEditor*)p);
   }
   static void destruct_TGeoConeSegEditor(void *p) {
      typedef ::TGeoConeSegEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoConeSegEditor(TBuffer &buf, void *obj) {
      ((::TGeoConeSegEditor*)obj)->::TGeoConeSegEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoConeSegEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTrd1Editor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTrd1Editor.
      TClass *R__cl = ::TGeoTrd1Editor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi1", &fDxi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi2", &fDxi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx1", &fEDx1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx2", &fEDx2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy", &fEDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTrd1Editor(void *p) {
      return  p ? new(p) ::TGeoTrd1Editor : new ::TGeoTrd1Editor;
   }
   static void *newArray_TGeoTrd1Editor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTrd1Editor[nElements] : new ::TGeoTrd1Editor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTrd1Editor(void *p) {
      delete ((::TGeoTrd1Editor*)p);
   }
   static void deleteArray_TGeoTrd1Editor(void *p) {
      delete [] ((::TGeoTrd1Editor*)p);
   }
   static void destruct_TGeoTrd1Editor(void *p) {
      typedef ::TGeoTrd1Editor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTrd1Editor(TBuffer &buf, void *obj) {
      ((::TGeoTrd1Editor*)obj)->::TGeoTrd1Editor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTrd1Editor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoParaEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoParaEditor.
      TClass *R__cl = ::TGeoParaEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXi", &fXi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYi", &fYi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZi", &fZi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlphai", &fAlphai);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx", &fEDx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy", &fEDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEAlpha", &fEAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta", &fETheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi", &fEPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoParaEditor(void *p) {
      return  p ? new(p) ::TGeoParaEditor : new ::TGeoParaEditor;
   }
   static void *newArray_TGeoParaEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoParaEditor[nElements] : new ::TGeoParaEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoParaEditor(void *p) {
      delete ((::TGeoParaEditor*)p);
   }
   static void deleteArray_TGeoParaEditor(void *p) {
      delete [] ((::TGeoParaEditor*)p);
   }
   static void destruct_TGeoParaEditor(void *p) {
      typedef ::TGeoParaEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoParaEditor(TBuffer &buf, void *obj) {
      ((::TGeoParaEditor*)obj)->::TGeoParaEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoParaEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTorusEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTorusEditor.
      TClass *R__cl = ::TGeoTorusEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRi", &fRi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini", &fRmini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi", &fRmaxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1i", &fPhi1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDphii", &fDphii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fER", &fER);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDphi", &fEDphi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTorusEditor(void *p) {
      return  p ? new(p) ::TGeoTorusEditor : new ::TGeoTorusEditor;
   }
   static void *newArray_TGeoTorusEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTorusEditor[nElements] : new ::TGeoTorusEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTorusEditor(void *p) {
      delete ((::TGeoTorusEditor*)p);
   }
   static void deleteArray_TGeoTorusEditor(void *p) {
      delete [] ((::TGeoTorusEditor*)p);
   }
   static void destruct_TGeoTorusEditor(void *p) {
      typedef ::TGeoTorusEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTorusEditor(TBuffer &buf, void *obj) {
      ((::TGeoTorusEditor*)obj)->::TGeoTorusEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTorusEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoPconEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoPconEditor.
      TClass *R__cl = ::TGeoPconEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsecti", &fNsecti);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1i", &fPhi1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDPhii", &fDPhii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZi", &fZi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmini", &fRmini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmaxi", &fRmaxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsections", &fNsections);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSections", &fSections);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCan", &fCan);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLHsect", &fLHsect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fENz", &fENz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDPhi", &fEDPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPconEditor(void *p) {
      return  p ? new(p) ::TGeoPconEditor : new ::TGeoPconEditor;
   }
   static void *newArray_TGeoPconEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPconEditor[nElements] : new ::TGeoPconEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPconEditor(void *p) {
      delete ((::TGeoPconEditor*)p);
   }
   static void deleteArray_TGeoPconEditor(void *p) {
      delete [] ((::TGeoPconEditor*)p);
   }
   static void destruct_TGeoPconEditor(void *p) {
      typedef ::TGeoPconEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoPconEditor(TBuffer &buf, void *obj) {
      ((::TGeoPconEditor*)obj)->::TGeoPconEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoPconEditor

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

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

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

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

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

   TGeoPconEditor::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPgonEditor(void *p) {
      return  p ? new(p) ::TGeoPgonEditor : new ::TGeoPgonEditor;
   }
   static void *newArray_TGeoPgonEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPgonEditor[nElements] : new ::TGeoPgonEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPgonEditor(void *p) {
      delete ((::TGeoPgonEditor*)p);
   }
   static void deleteArray_TGeoPgonEditor(void *p) {
      delete [] ((::TGeoPgonEditor*)p);
   }
   static void destruct_TGeoPgonEditor(void *p) {
      typedef ::TGeoPgonEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoPgonEditor(TBuffer &buf, void *obj) {
      ((::TGeoPgonEditor*)obj)->::TGeoPgonEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoPgonEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTrd2Editor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTrd2Editor.
      TClass *R__cl = ::TGeoTrd2Editor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi1", &fDxi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi2", &fDxi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi1", &fDyi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi2", &fDyi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx1", &fEDx1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx2", &fEDx2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy1", &fEDy1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy2", &fEDy2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTrd2Editor(void *p) {
      return  p ? new(p) ::TGeoTrd2Editor : new ::TGeoTrd2Editor;
   }
   static void *newArray_TGeoTrd2Editor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTrd2Editor[nElements] : new ::TGeoTrd2Editor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTrd2Editor(void *p) {
      delete ((::TGeoTrd2Editor*)p);
   }
   static void deleteArray_TGeoTrd2Editor(void *p) {
      delete [] ((::TGeoTrd2Editor*)p);
   }
   static void destruct_TGeoTrd2Editor(void *p) {
      typedef ::TGeoTrd2Editor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTrd2Editor(TBuffer &buf, void *obj) {
      ((::TGeoTrd2Editor*)obj)->::TGeoTrd2Editor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTrd2Editor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTrapEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTrapEditor.
      TClass *R__cl = ::TGeoTrapEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fH1i", &fH1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl1i", &fBl1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl1i", &fTl1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSci", &fSci);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha1i", &fAlpha1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEH1", &fEH1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEBl1", &fEBl1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETl1", &fETl1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fESc1", &fESc1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fESc2", &fESc2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEAlpha1", &fEAlpha1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta", &fETheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi", &fEPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTrapEditor(void *p) {
      return  p ? new(p) ::TGeoTrapEditor : new ::TGeoTrapEditor;
   }
   static void *newArray_TGeoTrapEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTrapEditor[nElements] : new ::TGeoTrapEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTrapEditor(void *p) {
      delete ((::TGeoTrapEditor*)p);
   }
   static void deleteArray_TGeoTrapEditor(void *p) {
      delete [] ((::TGeoTrapEditor*)p);
   }
   static void destruct_TGeoTrapEditor(void *p) {
      typedef ::TGeoTrapEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTrapEditor(TBuffer &buf, void *obj) {
      ((::TGeoTrapEditor*)obj)->::TGeoTrapEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTrapEditor

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

   TGeoTrapEditor::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoGtraEditor(void *p) {
      return  p ? new(p) ::TGeoGtraEditor : new ::TGeoGtraEditor;
   }
   static void *newArray_TGeoGtraEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoGtraEditor[nElements] : new ::TGeoGtraEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoGtraEditor(void *p) {
      delete ((::TGeoGtraEditor*)p);
   }
   static void deleteArray_TGeoGtraEditor(void *p) {
      delete [] ((::TGeoGtraEditor*)p);
   }
   static void destruct_TGeoGtraEditor(void *p) {
      typedef ::TGeoGtraEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoGtraEditor(TBuffer &buf, void *obj) {
      ((::TGeoGtraEditor*)obj)->::TGeoGtraEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoGtraEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoSphereEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoSphereEditor.
      TClass *R__cl = ::TGeoSphereEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini", &fRmini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi", &fRmaxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta1i", &fTheta1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta2i", &fTheta2i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1i", &fPhi1i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi2i", &fPhi2i);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta1", &fETheta1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta2", &fETheta2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi2", &fEPhi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSPhi", &fSPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSTheta", &fSTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoSphereEditor(void *p) {
      return  p ? new(p) ::TGeoSphereEditor : new ::TGeoSphereEditor;
   }
   static void *newArray_TGeoSphereEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoSphereEditor[nElements] : new ::TGeoSphereEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoSphereEditor(void *p) {
      delete ((::TGeoSphereEditor*)p);
   }
   static void deleteArray_TGeoSphereEditor(void *p) {
      delete [] ((::TGeoSphereEditor*)p);
   }
   static void destruct_TGeoSphereEditor(void *p) {
      typedef ::TGeoSphereEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoSphereEditor(TBuffer &buf, void *obj) {
      ((::TGeoSphereEditor*)obj)->::TGeoSphereEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoSphereEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoMediumEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoMediumEditor.
      TClass *R__cl = ::TGeoMediumEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedium", &fMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedName", &fMedName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedId", &fMedId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMaterial", &fSelectedMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMaterial", &fLSelMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMaterial", &fBSelMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMaterial", &fEditMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedSensitive", &fMedSensitive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMagfldOption", &fMagfldOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedFieldm", &fMedFieldm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedTmaxfd", &fMedTmaxfd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedStemax", &fMedStemax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedDeemax", &fMedDeemax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedEpsil", &fMedEpsil);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedStmin", &fMedStmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoMediumEditor(void *p) {
      return  p ? new(p) ::TGeoMediumEditor : new ::TGeoMediumEditor;
   }
   static void *newArray_TGeoMediumEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoMediumEditor[nElements] : new ::TGeoMediumEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoMediumEditor(void *p) {
      delete ((::TGeoMediumEditor*)p);
   }
   static void deleteArray_TGeoMediumEditor(void *p) {
      delete [] ((::TGeoMediumEditor*)p);
   }
   static void destruct_TGeoMediumEditor(void *p) {
      typedef ::TGeoMediumEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoMediumEditor(TBuffer &buf, void *obj) {
      ((::TGeoMediumEditor*)obj)->::TGeoMediumEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoMediumEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoMaterialEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoMaterialEditor.
      TClass *R__cl = ::TGeoMaterialEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAi", &fAi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZi", &fZi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatei", &fStatei);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDensityi", &fDensityi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTempi", &fTempi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPresi", &fPresi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterial", &fMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMaterialEditable", &fIsMaterialEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialName", &fMaterialName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatA", &fMatA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatZ", &fMatZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatState", &fMatState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatDensity", &fMatDensity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatTemperature", &fMatTemperature);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatPressure", &fMatPressure);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatRadLen", &fMatRadLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatAbsLen", &fMatAbsLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f23", &f23);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoMaterialEditor(void *p) {
      return  p ? new(p) ::TGeoMaterialEditor : new ::TGeoMaterialEditor;
   }
   static void *newArray_TGeoMaterialEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoMaterialEditor[nElements] : new ::TGeoMaterialEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoMaterialEditor(void *p) {
      delete ((::TGeoMaterialEditor*)p);
   }
   static void deleteArray_TGeoMaterialEditor(void *p) {
      delete [] ((::TGeoMaterialEditor*)p);
   }
   static void destruct_TGeoMaterialEditor(void *p) {
      typedef ::TGeoMaterialEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoMaterialEditor(TBuffer &buf, void *obj) {
      ((::TGeoMaterialEditor*)obj)->::TGeoMaterialEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoMaterialEditor

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

   TGeoMaterialEditor::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoMixtureEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoMixtureEditor.
      TClass *R__cl = ::TGeoMixtureEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMixture", &fMixture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMixElem", &fMixElem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNelem", &fNelem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAelem", &fAelem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZelem", &fZelem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChkFraction", &fChkFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNEFraction", &fNEFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChkNatoms", &fChkNatoms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNENatoms", &fNENatoms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBAddElem", &fBAddElem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComps", &fComps);
      TGeoMaterialEditor::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoMixtureEditor(void *p) {
      return  p ? new(p) ::TGeoMixtureEditor : new ::TGeoMixtureEditor;
   }
   static void *newArray_TGeoMixtureEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoMixtureEditor[nElements] : new ::TGeoMixtureEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoMixtureEditor(void *p) {
      delete ((::TGeoMixtureEditor*)p);
   }
   static void deleteArray_TGeoMixtureEditor(void *p) {
      delete [] ((::TGeoMixtureEditor*)p);
   }
   static void destruct_TGeoMixtureEditor(void *p) {
      typedef ::TGeoMixtureEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoMixtureEditor(TBuffer &buf, void *obj) {
      ((::TGeoMixtureEditor*)obj)->::TGeoMixtureEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoMixtureEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoNodeEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoNodeEditor.
      TClass *R__cl = ::TGeoNodeEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNode", &fNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeName", &fNodeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeNumber", &fNodeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedVolume", &fSelectedVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelVolume", &fLSelVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelVolume", &fBSelVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMother", &fSelectedMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMother", &fLSelMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMother", &fBSelMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMatrix", &fSelectedMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMatrix", &fLSelMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMatrix", &fBSelMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMother", &fEditMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditVolume", &fEditVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMatrix", &fEditMatrix);
      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(), "*fUndo", &fUndo);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoNodeEditor(void *p) {
      return  p ? new(p) ::TGeoNodeEditor : new ::TGeoNodeEditor;
   }
   static void *newArray_TGeoNodeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoNodeEditor[nElements] : new ::TGeoNodeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoNodeEditor(void *p) {
      delete ((::TGeoNodeEditor*)p);
   }
   static void deleteArray_TGeoNodeEditor(void *p) {
      delete [] ((::TGeoNodeEditor*)p);
   }
   static void destruct_TGeoNodeEditor(void *p) {
      typedef ::TGeoNodeEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoNodeEditor(TBuffer &buf, void *obj) {
      ((::TGeoNodeEditor*)obj)->::TGeoNodeEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoNodeEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTranslationEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTranslationEditor.
      TClass *R__cl = ::TGeoTranslationEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi", &fDxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTranslation", &fTranslation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransName", &fTransName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDx", &fTransDx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDy", &fTransDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDz", &fTransDz);
      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(), "*fUndo", &fUndo);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTranslationEditor(void *p) {
      return  p ? new(p) ::TGeoTranslationEditor : new ::TGeoTranslationEditor;
   }
   static void *newArray_TGeoTranslationEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTranslationEditor[nElements] : new ::TGeoTranslationEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTranslationEditor(void *p) {
      delete ((::TGeoTranslationEditor*)p);
   }
   static void deleteArray_TGeoTranslationEditor(void *p) {
      delete [] ((::TGeoTranslationEditor*)p);
   }
   static void destruct_TGeoTranslationEditor(void *p) {
      typedef ::TGeoTranslationEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoTranslationEditor(TBuffer &buf, void *obj) {
      ((::TGeoTranslationEditor*)obj)->::TGeoTranslationEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoTranslationEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoRotationEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoRotationEditor.
      TClass *R__cl = ::TGeoRotationEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsii", &fPsii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleX", &fAngleX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleY", &fAngleY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleZ", &fAngleZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotation", &fRotation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotName", &fRotName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPhi", &fRotPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotTheta", &fRotTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPsi", &fRotPsi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotAxis", &fRotAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotX", &fRotX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotY", &fRotY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotZ", &fRotZ);
      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(), "*fUndo", &fUndo);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoRotationEditor(void *p) {
      return  p ? new(p) ::TGeoRotationEditor : new ::TGeoRotationEditor;
   }
   static void *newArray_TGeoRotationEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoRotationEditor[nElements] : new ::TGeoRotationEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoRotationEditor(void *p) {
      delete ((::TGeoRotationEditor*)p);
   }
   static void deleteArray_TGeoRotationEditor(void *p) {
      delete [] ((::TGeoRotationEditor*)p);
   }
   static void destruct_TGeoRotationEditor(void *p) {
      typedef ::TGeoRotationEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoRotationEditor(TBuffer &buf, void *obj) {
      ((::TGeoRotationEditor*)obj)->::TGeoRotationEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoRotationEditor

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

   TGeoGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoCombiTransEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoCombiTransEditor.
      TClass *R__cl = ::TGeoCombiTransEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi", &fDxi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsii", &fPsii);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleX", &fAngleX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleY", &fAngleY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleZ", &fAngleZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
      R__insp.InspectMember(fNamei, "fNamei.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCombi", &fCombi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotName", &fRotName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDx", &fTransDx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDy", &fTransDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDz", &fTransDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPhi", &fRotPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotTheta", &fRotTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPsi", &fRotPsi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotAxis", &fRotAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotX", &fRotX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotY", &fRotY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotZ", &fRotZ);
      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(), "*fUndo", &fUndo);
      TGeoGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoCombiTransEditor(void *p) {
      return  p ? new(p) ::TGeoCombiTransEditor : new ::TGeoCombiTransEditor;
   }
   static void *newArray_TGeoCombiTransEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoCombiTransEditor[nElements] : new ::TGeoCombiTransEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoCombiTransEditor(void *p) {
      delete ((::TGeoCombiTransEditor*)p);
   }
   static void deleteArray_TGeoCombiTransEditor(void *p) {
      delete [] ((::TGeoCombiTransEditor*)p);
   }
   static void destruct_TGeoCombiTransEditor(void *p) {
      typedef ::TGeoCombiTransEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoCombiTransEditor(TBuffer &buf, void *obj) {
      ((::TGeoCombiTransEditor*)obj)->::TGeoCombiTransEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoCombiTransEditor

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

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoManagerEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoManagerEditor.
      TClass *R__cl = ::TGeoManagerEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometry", &fGeometry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabMgr", &fTabMgr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeTab", &fVolumeTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCategories", &fCategories);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManagerName", &fManagerName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManagerTitle", &fManagerTitle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumName", &fMediumName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixName", &fMatrixName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialName", &fMaterialName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeName", &fVolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMaterial", &fSelectedMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMaterial2", &fSelectedMaterial2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMaterial", &fLSelMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMaterial2", &fLSelMaterial2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMaterial", &fBSelMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMaterial2", &fBSelMaterial2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedVolume", &fSelectedVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelVolume", &fLSelVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelVolume", &fBSelVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedShape", &fSelectedShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedShape2", &fSelectedShape2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelShape", &fLSelShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelShape2", &fLSelShape2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelShape", &fBSelShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelShape2", &fBSelShape2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMatrix", &fSelectedMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMatrix", &fLSelMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMatrix", &fBSelMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMedium", &fSelectedMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMedium2", &fSelectedMedium2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMedium", &fLSelMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMedium2", &fLSelMedium2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMedium", &fBSelMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMedium2", &fBSelMedium2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeButton[21]", &fShapeButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixButton[3]", &fMatrixButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeButton[2]", &fVolumeButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialButton[2]", &fMaterialButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExportOption[2]", &fExportOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExportButton", &fExportButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElementList", &fElementList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryDensity", &fEntryDensity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumButton", &fMediumButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumId", &fMediumId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditShape", &fEditShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMedium", &fEditMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMaterial", &fEditMaterial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMatrix", &fEditMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditVolume", &fEditVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSetTopVolume", &fSetTopVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelTop", &fLSelTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelTop", &fBSelTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCloseGeometry", &fCloseGeometry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f2", &f2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3", &f3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f4", &f4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f5", &f5);
      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(), "*fConnectedCanvas", &fConnectedCanvas);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoManagerEditor(void *p) {
      return  p ? new(p) ::TGeoManagerEditor : new ::TGeoManagerEditor;
   }
   static void *newArray_TGeoManagerEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoManagerEditor[nElements] : new ::TGeoManagerEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoManagerEditor(void *p) {
      delete ((::TGeoManagerEditor*)p);
   }
   static void deleteArray_TGeoManagerEditor(void *p) {
      delete [] ((::TGeoManagerEditor*)p);
   }
   static void destruct_TGeoManagerEditor(void *p) {
      typedef ::TGeoManagerEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoManagerEditor(TBuffer &buf, void *obj) {
      ((::TGeoManagerEditor*)obj)->::TGeoManagerEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoManagerEditor

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTabManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTabManager.
      TClass *R__cl = ::TGeoTabManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapePanel", &fShapePanel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumPanel", &fMediumPanel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialPanel", &fMaterialPanel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixPanel", &fMatrixPanel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeTab", &fVolumeTab);
      TObject::ShowMembers(R__insp);
}

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

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

   TGMainFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGeoTransientPanel::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTransientPanel.
      TClass *R__cl = ::TGeoTransientPanel::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
      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(), "*fTabContainer", &fTabContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyle", &fStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModel", &fModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClose", &fClose);
      TGMainFrame::ShowMembers(R__insp);
}

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

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

   TGTransientFrame::Streamer(R__b);
}

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

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

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

   TGeoTreeDialog::Streamer(R__b);
}

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

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

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

   TGeoTreeDialog::Streamer(R__b);
}

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

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

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

   TGeoTreeDialog::Streamer(R__b);
}

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

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

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

   TGeoTreeDialog::Streamer(R__b);
}

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

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

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

   TGeoTreeDialog::Streamer(R__b);
}

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

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

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

   TGedFrame::Streamer(R__b);
}

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

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

/********************************************************
* geom/geombuilder/src/G__GeomBuilder.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__GeomBuilder();

extern "C" void G__set_cpp_environmentG__GeomBuilder() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TGeoVolumeEditor.h");
  G__add_compiledheader("TGeoBBoxEditor.h");
  G__add_compiledheader("TGeoMediumEditor.h");
  G__add_compiledheader("TGeoNodeEditor.h");
  G__add_compiledheader("TGeoMatrixEditor.h");
  G__add_compiledheader("TGeoManagerEditor.h");
  G__add_compiledheader("TGeoTubeEditor.h");
  G__add_compiledheader("TGeoConeEditor.h");
  G__add_compiledheader("TGeoTrd1Editor.h");
  G__add_compiledheader("TGeoTrd2Editor.h");
  G__add_compiledheader("TGeoMaterialEditor.h");
  G__add_compiledheader("TGeoTabManager.h");
  G__add_compiledheader("TGeoSphereEditor.h");
  G__add_compiledheader("TGeoPconEditor.h");
  G__add_compiledheader("TGeoParaEditor.h");
  G__add_compiledheader("TGeoTorusEditor.h");
  G__add_compiledheader("TGeoEltuEditor.h");
  G__add_compiledheader("TGeoHypeEditor.h");
  G__add_compiledheader("TGeoPgonEditor.h");
  G__add_compiledheader("TGeoTrapEditor.h");
  G__add_compiledheader("TGeoGedFrame.h");
  G__cpp_reset_tagtableG__GeomBuilder();
}
#include <new>
extern "C" int G__cpp_dllrevG__GeomBuilder() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

static int G__G__GeomBuilder_258_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTabManager*) G__getstructoffset())->GetShapeEditor((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_258_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTabManager*) G__getstructoffset())->GetVolumeEditor((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_258_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTabManager*) G__getstructoffset())->GetMatrixEditor((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_258_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTabManager*) G__getstructoffset())->GetMediumEditor((TGeoMedium*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_258_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTabManager*) G__getstructoffset())->GetMaterialEditor((TGeoMaterial*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__GeomBuilder_286_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoManagerEditor::LoadLib();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_286_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManagerEditor*) G__getstructoffset())->SelectedSlot((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__GeomBuilder_286_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManagerEditor*) G__getstructoffset())->ConnectSelected((TCanvas*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGeoTreeDialog */
static int G__G__GeomBuilder_311_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTreeDialog::GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__GeomBuilder_311_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTreeDialog*) G__getstructoffset())->DoSelect((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__GeomBuilder_317_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMatrixDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoMatrixDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoMatrixDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrixDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMatrixDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMatrixDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMatrixDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_317_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMatrixDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMatrixDialog G__TTGeoMatrixDialog;
static int G__G__GeomBuilder_317_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[] (TGeoMatrixDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoMatrixDialog*) (soff+(sizeof(TGeoMatrixDialog)*i)))->~G__TTGeoMatrixDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoMatrixDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoMatrixDialog*) (soff))->~G__TTGeoMatrixDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoSphereEditor */
static int G__G__GeomBuilder_319_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSphereEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphereEditor(
(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) TGeoSphereEditor(
(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 TGeoSphereEditor(
(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) TGeoSphereEditor(
(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 TGeoSphereEditor(
(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) TGeoSphereEditor(
(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 TGeoSphereEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoSphereEditor((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 TGeoSphereEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoSphereEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoSphereEditor[n];
       } else {
         p = new((void*) gvp) TGeoSphereEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoSphereEditor;
       } else {
         p = new((void*) gvp) TGeoSphereEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoRmin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoRmax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoPhi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoTheta();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoTheta1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoTheta2();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoPhi1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoPhi2();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoSphereEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSphereEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoSphereEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoSphereEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphereEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSphereEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoSphereEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSphereEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_319_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoSphereEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoSphereEditor G__TTGeoSphereEditor;
static int G__G__GeomBuilder_319_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[] (TGeoSphereEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoSphereEditor*) (soff+(sizeof(TGeoSphereEditor)*i)))->~G__TTGeoSphereEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoSphereEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoSphereEditor*) (soff))->~G__TTGeoSphereEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPconSection */
static int G__G__GeomBuilder_321_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPconSection* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPconSection(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoPconSection(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->HideDaughters();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPconSection*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPconSection*) G__getstructoffset())->GetRmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPconSection*) G__getstructoffset())->GetRmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->SetZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->SetRmin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->SetRmax((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->DoZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->DoRmin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->DoRmax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->Changed((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPconSection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPconSection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPconSection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPconSection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconSection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPconSection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPconSection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPconSection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_321_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPconSection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPconSection G__TTGeoPconSection;
static int G__G__GeomBuilder_321_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[] (TGeoPconSection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPconSection*) (soff+(sizeof(TGeoPconSection)*i)))->~G__TTGeoPconSection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPconSection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPconSection*) (soff))->~G__TTGeoPconSection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPconEditor */
static int G__G__GeomBuilder_322_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPconEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPconEditor(
(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) TGeoPconEditor(
(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 TGeoPconEditor(
(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) TGeoPconEditor(
(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 TGeoPconEditor(
(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) TGeoPconEditor(
(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 TGeoPconEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoPconEditor((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 TGeoPconEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoPconEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoPconEditor[n];
       } else {
         p = new((void*) gvp) TGeoPconEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoPconEditor;
       } else {
         p = new((void*) gvp) TGeoPconEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoNz();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoPhi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoSectionChange((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPconEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPconEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPconEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPconEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPconEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPconEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPconEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPconEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_322_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPconEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPconEditor G__TTGeoPconEditor;
static int G__G__GeomBuilder_322_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoPconEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPconEditor*) (soff+(sizeof(TGeoPconEditor)*i)))->~G__TTGeoPconEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPconEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPconEditor*) (soff))->~G__TTGeoPconEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoParaEditor */
static int G__G__GeomBuilder_324_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoParaEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoParaEditor(
(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) TGeoParaEditor(
(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 TGeoParaEditor(
(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) TGeoParaEditor(
(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 TGeoParaEditor(
(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) TGeoParaEditor(
(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 TGeoParaEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoParaEditor((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 TGeoParaEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoParaEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoParaEditor[n];
       } else {
         p = new((void*) gvp) TGeoParaEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoParaEditor;
       } else {
         p = new((void*) gvp) TGeoParaEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoAlpha();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoTheta();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoPhi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoParaEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoParaEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoParaEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoParaEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoParaEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoParaEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoParaEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_324_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoParaEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoParaEditor G__TTGeoParaEditor;
static int G__G__GeomBuilder_324_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoParaEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoParaEditor*) (soff+(sizeof(TGeoParaEditor)*i)))->~G__TTGeoParaEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoParaEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoParaEditor*) (soff))->~G__TTGeoParaEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTorusEditor */
static int G__G__GeomBuilder_326_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTorusEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorusEditor(
(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) TGeoTorusEditor(
(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 TGeoTorusEditor(
(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) TGeoTorusEditor(
(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 TGeoTorusEditor(
(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) TGeoTorusEditor(
(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 TGeoTorusEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoTorusEditor((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 TGeoTorusEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoTorusEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoTorusEditor[n];
       } else {
         p = new((void*) gvp) TGeoTorusEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoTorusEditor;
       } else {
         p = new((void*) gvp) TGeoTorusEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoR();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoRmin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoRmax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoPhi1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoDphi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTorusEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTorusEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTorusEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTorusEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorusEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTorusEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTorusEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTorusEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_326_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTorusEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTorusEditor G__TTGeoTorusEditor;
static int G__G__GeomBuilder_326_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[] (TGeoTorusEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTorusEditor*) (soff+(sizeof(TGeoTorusEditor)*i)))->~G__TTGeoTorusEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTorusEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTorusEditor*) (soff))->~G__TTGeoTorusEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoEltuEditor */
static int G__G__GeomBuilder_328_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoEltuEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoEltuEditor(
(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) TGeoEltuEditor(
(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 TGeoEltuEditor(
(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) TGeoEltuEditor(
(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 TGeoEltuEditor(
(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) TGeoEltuEditor(
(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 TGeoEltuEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoEltuEditor((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 TGeoEltuEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoEltuEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoEltuEditor[n];
       } else {
         p = new((void*) gvp) TGeoEltuEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoEltuEditor;
       } else {
         p = new((void*) gvp) TGeoEltuEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoA();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoB();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoDz();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoEltuEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoEltuEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoEltuEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoEltuEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltuEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoEltuEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoEltuEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoEltuEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_328_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoEltuEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoEltuEditor G__TTGeoEltuEditor;
static int G__G__GeomBuilder_328_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[] (TGeoEltuEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoEltuEditor*) (soff+(sizeof(TGeoEltuEditor)*i)))->~G__TTGeoEltuEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoEltuEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoEltuEditor*) (soff))->~G__TTGeoEltuEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHypeEditor */
static int G__G__GeomBuilder_330_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHypeEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHypeEditor(
(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) TGeoHypeEditor(
(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 TGeoHypeEditor(
(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) TGeoHypeEditor(
(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 TGeoHypeEditor(
(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) TGeoHypeEditor(
(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 TGeoHypeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoHypeEditor((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 TGeoHypeEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoHypeEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoHypeEditor[n];
       } else {
         p = new((void*) gvp) TGeoHypeEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoHypeEditor;
       } else {
         p = new((void*) gvp) TGeoHypeEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoRin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoRout();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoDz();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoStIn();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoStOut();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoHypeEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHypeEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoHypeEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoHypeEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHypeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHypeEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHypeEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHypeEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_330_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHypeEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoHypeEditor G__TTGeoHypeEditor;
static int G__G__GeomBuilder_330_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[] (TGeoHypeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoHypeEditor*) (soff+(sizeof(TGeoHypeEditor)*i)))->~G__TTGeoHypeEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoHypeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoHypeEditor*) (soff))->~G__TTGeoHypeEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPgonEditor */
static int G__G__GeomBuilder_331_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPgonEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPgonEditor(
(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) TGeoPgonEditor(
(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 TGeoPgonEditor(
(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) TGeoPgonEditor(
(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 TGeoPgonEditor(
(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) TGeoPgonEditor(
(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 TGeoPgonEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoPgonEditor((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 TGeoPgonEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoPgonEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoPgonEditor[n];
       } else {
         p = new((void*) gvp) TGeoPgonEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoPgonEditor;
       } else {
         p = new((void*) gvp) TGeoPgonEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPgonEditor*) G__getstructoffset())->DoNedges();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPgonEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPgonEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPgonEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPgonEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPgonEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPgonEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPgonEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPgonEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_331_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPgonEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPgonEditor G__TTGeoPgonEditor;
static int G__G__GeomBuilder_331_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[] (TGeoPgonEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPgonEditor*) (soff+(sizeof(TGeoPgonEditor)*i)))->~G__TTGeoPgonEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPgonEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPgonEditor*) (soff))->~G__TTGeoPgonEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTrapEditor */
static int G__G__GeomBuilder_333_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrapEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrapEditor(
(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) TGeoTrapEditor(
(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 TGeoTrapEditor(
(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) TGeoTrapEditor(
(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 TGeoTrapEditor(
(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) TGeoTrapEditor(
(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 TGeoTrapEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoTrapEditor((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 TGeoTrapEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoTrapEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoTrapEditor[n];
       } else {
         p = new((void*) gvp) TGeoTrapEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoTrapEditor;
       } else {
         p = new((void*) gvp) TGeoTrapEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoH1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoBl1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoTl1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoDz();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoSc1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoSc2();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoAlpha1();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoTheta();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoPhi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoApply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->DoUndo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTrapEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrapEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTrapEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTrapEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrapEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrapEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrapEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrapEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_333_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrapEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTrapEditor G__TTGeoTrapEditor;
static int G__G__GeomBuilder_333_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoTrapEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTrapEditor*) (soff+(sizeof(TGeoTrapEditor)*i)))->~G__TTGeoTrapEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTrapEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTrapEditor*) (soff))->~G__TTGeoTrapEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoGtraEditor */
static int G__G__GeomBuilder_334_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGtraEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoGtraEditor(
(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) TGeoGtraEditor(
(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 TGeoGtraEditor(
(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) TGeoGtraEditor(
(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 TGeoGtraEditor(
(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) TGeoGtraEditor(
(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 TGeoGtraEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoGtraEditor((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 TGeoGtraEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoGtraEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoGtraEditor[n];
       } else {
         p = new((void*) gvp) TGeoGtraEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGeoGtraEditor;
       } else {
         p = new((void*) gvp) TGeoGtraEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoGtraEditor*) G__getstructoffset())->DoTwist();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoGtraEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGtraEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoGtraEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoGtraEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoGtraEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGtraEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoGtraEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGtraEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GeomBuilder_334_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoGtraEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoGtraEditor G__TTGeoGtraEditor;
static int G__G__GeomBuilder_334_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[] (TGeoGtraEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoGtraEditor*) (soff+(sizeof(TGeoGtraEditor)*i)))->~G__TTGeoGtraEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoGtraEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoGtraEditor*) (soff))->~G__TTGeoGtraEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TGeoTabManager */

/* TGeoGedFrame */

/* TGeoVolumeEditor */

/* TGeoBBoxEditor */

/* TGeoMediumEditor */

/* TGeoNodeEditor */

/* TGeoTranslationEditor */

/* TGeoRotationEditor */

/* TGeoCombiTransEditor */

/* TGeoManagerEditor */

/* TGeoTubeEditor */

/* TGeoTubeSegEditor */

/* TGeoCtubEditor */

/* TGeoConeEditor */

/* TGeoConeSegEditor */

/* TGeoTrd1Editor */

/* TGeoTrd2Editor */

/* TGeoMaterialEditor */

/* TGeoMixtureEditor */

/* TGeoTreeDialog */

/* TGeoTransientPanel */

/* TGeoVolumeDialog */

/* TGeoShapeDialog */

/* TGeoMediumDialog */

/* TGeoMaterialDialog */

/* TGeoMatrixDialog */

/* TGeoSphereEditor */

/* TGeoPconSection */

/* TGeoPconEditor */

/* TGeoParaEditor */

/* TGeoTorusEditor */

/* TGeoEltuEditor */

/* TGeoHypeEditor */

/* TGeoPgonEditor */

/* TGeoTrapEditor */

/* TGeoGtraEditor */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__GeomBuilder {
 public:
  G__Sizep2memfuncG__GeomBuilder(): p(&G__Sizep2memfuncG__GeomBuilder::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__GeomBuilder::*p)();
};

size_t G__get_sizep2memfuncG__GeomBuilder()
{
  G__Sizep2memfuncG__GeomBuilder 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__GeomBuilder() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager))) {
     TGeoTabManager *G__Lderived;
     G__Lderived=(TGeoTabManager*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame))) {
     TGeoGedFrame *G__Lderived;
     G__Lderived=(TGeoGedFrame*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor))) {
     TGeoVolumeEditor *G__Lderived;
     G__Lderived=(TGeoVolumeEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor))) {
     TGeoBBoxEditor *G__Lderived;
     G__Lderived=(TGeoBBoxEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor))) {
     TGeoMediumEditor *G__Lderived;
     G__Lderived=(TGeoMediumEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor))) {
     TGeoNodeEditor *G__Lderived;
     G__Lderived=(TGeoNodeEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor))) {
     TGeoTranslationEditor *G__Lderived;
     G__Lderived=(TGeoTranslationEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor))) {
     TGeoRotationEditor *G__Lderived;
     G__Lderived=(TGeoRotationEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor))) {
     TGeoCombiTransEditor *G__Lderived;
     G__Lderived=(TGeoCombiTransEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor))) {
     TGeoManagerEditor *G__Lderived;
     G__Lderived=(TGeoManagerEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor))) {
     TGeoTubeEditor *G__Lderived;
     G__Lderived=(TGeoTubeEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor))) {
     TGeoTubeSegEditor *G__Lderived;
     G__Lderived=(TGeoTubeSegEditor*)0x1000;
     {
       TGeoTubeEditor *G__Lpbase=(TGeoTubeEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor))) {
     TGeoCtubEditor *G__Lderived;
     G__Lderived=(TGeoCtubEditor*)0x1000;
     {
       TGeoTubeSegEditor *G__Lpbase=(TGeoTubeSegEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoTubeEditor *G__Lpbase=(TGeoTubeEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor))) {
     TGeoConeEditor *G__Lderived;
     G__Lderived=(TGeoConeEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor))) {
     TGeoConeSegEditor *G__Lderived;
     G__Lderived=(TGeoConeSegEditor*)0x1000;
     {
       TGeoConeEditor *G__Lpbase=(TGeoConeEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor))) {
     TGeoTrd1Editor *G__Lderived;
     G__Lderived=(TGeoTrd1Editor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor))) {
     TGeoTrd2Editor *G__Lderived;
     G__Lderived=(TGeoTrd2Editor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor))) {
     TGeoMaterialEditor *G__Lderived;
     G__Lderived=(TGeoMaterialEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor))) {
     TGeoMixtureEditor *G__Lderived;
     G__Lderived=(TGeoMixtureEditor*)0x1000;
     {
       TGeoMaterialEditor *G__Lpbase=(TGeoMaterialEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog))) {
     TGeoTreeDialog *G__Lderived;
     G__Lderived=(TGeoTreeDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel))) {
     TGeoTransientPanel *G__Lderived;
     G__Lderived=(TGeoTransientPanel*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog))) {
     TGeoVolumeDialog *G__Lderived;
     G__Lderived=(TGeoVolumeDialog*)0x1000;
     {
       TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog))) {
     TGeoShapeDialog *G__Lderived;
     G__Lderived=(TGeoShapeDialog*)0x1000;
     {
       TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog))) {
     TGeoMediumDialog *G__Lderived;
     G__Lderived=(TGeoMediumDialog*)0x1000;
     {
       TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog))) {
     TGeoMaterialDialog *G__Lderived;
     G__Lderived=(TGeoMaterialDialog*)0x1000;
     {
       TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog))) {
     TGeoMatrixDialog *G__Lderived;
     G__Lderived=(TGeoMatrixDialog*)0x1000;
     {
       TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor))) {
     TGeoSphereEditor *G__Lderived;
     G__Lderived=(TGeoSphereEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection))) {
     TGeoPconSection *G__Lderived;
     G__Lderived=(TGeoPconSection*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor))) {
     TGeoPconEditor *G__Lderived;
     G__Lderived=(TGeoPconEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor))) {
     TGeoParaEditor *G__Lderived;
     G__Lderived=(TGeoParaEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor))) {
     TGeoTorusEditor *G__Lderived;
     G__Lderived=(TGeoTorusEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor))) {
     TGeoEltuEditor *G__Lderived;
     G__Lderived=(TGeoEltuEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor))) {
     TGeoHypeEditor *G__Lderived;
     G__Lderived=(TGeoHypeEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor))) {
     TGeoPgonEditor *G__Lderived;
     G__Lderived=(TGeoPgonEditor*)0x1000;
     {
       TGeoPconEditor *G__Lpbase=(TGeoPconEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor))) {
     TGeoTrapEditor *G__Lderived;
     G__Lderived=(TGeoTrapEditor*)0x1000;
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor))) {
     TGeoGtraEditor *G__Lderived;
     G__Lderived=(TGeoGtraEditor*)0x1000;
     {
       TGeoTrapEditor *G__Lpbase=(TGeoTrapEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__GeomBuilder() {

   /* 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("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("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilderLN_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__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned int,int> >",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilderLN_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__GeomBuilderLN_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__GeomBuilderLN_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__GeomBuilderLN_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__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TGeoTabManager */
static void G__setup_memvarTGeoTabManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager));
   { TGeoTabManager *p; p=(TGeoTabManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedEditor),-1,-1,4,"fGedEditor=",0,"Parent editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TVirtualPad),-1,-1,4,"fPad=",0,"Pad to which this applies");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,4,"fTab=",0,"Parent tab");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,4,"fVolume=",0,"Edited volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fShapePanel=",0,"Panel for editing shapes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fMediumPanel=",0,"Panel for editing media");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fMaterialPanel=",0,"Panel for editing materials");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fMatrixPanel=",0,"Panel for editing matrices");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,4,"fVolumeTab=",0,"Volume tab");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TMap),-1,-2,4,"fgEditorToMgrMap=",0,"Map from ged-editor to associated tab-manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoGedFrame */
static void G__setup_memvarTGeoGedFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame));
   { TGeoGedFrame *p; p=(TGeoGedFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,2,"fTab=",0,"tab of the ged-editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager),-1,-1,2,"fTabMgr=",0,"tab manager corresponding to ged-editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TVirtualPad),-1,-1,2,"fPad=",0,"selected pad, if exists");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoVolumeEditor */
static void G__setup_memvarTGeoVolumeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor));
   { TGeoVolumeEditor *p; p=(TGeoVolumeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManager),-1,-1,2,"fGeometry=",0,"Selected geometry manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fVolume=",0,"Volume object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsAssembly=",0,"Flag that the volume is an assembly");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsDivided=",0,"Flag that the volume is divided");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGShutter),-1,-1,2,"fCategories=",0,"Categories shutter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fVolumeName=",0,"Volume name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShape),-1,-1,2,"fSelectedShape=",0,"Selected shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelShape=",0,"Selected shape label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelShape=",0,"Button for selecting a shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fSelectedMedium=",0,"Selected medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMedium=",0,"Selected medium label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMedium=",0,"Button for selecting a medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedVolume=",0,"Selected volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelVolume=",0,"Selected volume label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelVolume=",0,"Button for selecting a volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrix),-1,-1,2,"fSelectedMatrix=",0,"Selected matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMatrix=",0,"Selected matrix label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMatrix=",0,"Button for selecting a matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fCopyNumber=",0,"Node copy number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fAddNode=",0,"Button for adding a node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditShape=",0,"Check button for shape editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMedium=",0,"Check button for medium editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fNodeList=",0,"Daughters combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMatrix=",0,"Button for editing the position of a daughter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fRemoveNode=",0,"Button for removing a daughter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fBVis[2]=",0,"Buttons for setting vis. on/off");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fBView[3]=",0,"Radio for selecting view options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fBRaytrace=",0,"Raytracing on/off");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fBAuto=",0,"Check button for auto vis level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEVisLevel=",0,"Number entry for visibility level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApplyDiv=",0,"Button for applying division settings");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fDivName=",0,"Division volume name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fBDiv[3]=",0,"Radio for selecting division type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDivFrom=",0,"Number entry for division start");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDivStep=",0,"Number entry for division step");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDivN=",0,"Number entry for division Nslices");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoBBoxEditor */
static void G__setup_memvarTGeoBBoxEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor));
   { TGeoBBoxEditor *p; p=(TGeoBBoxEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi=",0,"Initial box dx");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial box dy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial box dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOrigi[3]=",0,"Initial origin");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBox),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxDx=",0,"Number entry for box DX");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxDy=",0,"Number entry for box DY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxDz=",0,"Number entry for box DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxOx=",0,"Number entry for box OX");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxOy=",0,"Number entry for box OY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxOz=",0,"Number entry for box OZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMediumEditor */
static void G__setup_memvarTGeoMediumEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor));
   { TGeoMediumEditor *p; p=(TGeoMediumEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fMedium=",0,"Medium object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that the medium can be changed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Modified flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMedName=",0,"Medium name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedId=",0,"Number entry for medium id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fSelectedMaterial=",0,"Selected material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMaterial=",0,"Selected material label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMaterial=",0,"Button for selecting a material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMaterial=",0,"Check button for material editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fMedSensitive=",0,"Check button for sensitivity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fMagfldOption=",0,"Combo box with magnetic field options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedFieldm=",0,"Number entry for fieldm");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedTmaxfd=",0,"Number entry for tmaxfd");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedStemax=",0,"Number entry for stemax");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedDeemax=",0,"Number entry for deemax");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedEpsil=",0,"Number entry for epsil");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedStmin=",0,"Number entry for stmin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoNodeEditor */
static void G__setup_memvarTGeoNodeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor));
   { TGeoNodeEditor *p; p=(TGeoNodeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNode),-1,-1,2,"fNode=",0,"Node object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that the medium can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fNodeName=",0,"Node name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fNodeNumber=",0,"Copy number ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedVolume=",0,"Selected volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelVolume=",0,"Selected volume label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelVolume=",0,"Button for selecting a volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedMother=",0,"Selected mother");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMother=",0,"Selected mother label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMother=",0,"Button for selecting a mother volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrix),-1,-1,2,"fSelectedMatrix=",0,"Selected matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMatrix=",0,"Selected matrix label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMatrix=",0,"Button for selecting a matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMother=",0,"Check button for editing mother volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditVolume=",0,"Check button for volume editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMatrix=",0,"Check button for matrix editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTranslationEditor */
static void G__setup_memvarTGeoTranslationEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor));
   { TGeoTranslationEditor *p; p=(TGeoTranslationEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi=",0,"Initial dx");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial dy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial dz");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslation),-1,-1,2,"fTranslation=",0,"Translation object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that this was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that this can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fTransName=",0,"Translation name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDx=",0,"Number entry for box DX");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDy=",0,"Number entry for box DY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDz=",0,"Number entry for box DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoRotationEditor */
static void G__setup_memvarTGeoRotationEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor));
   { TGeoRotationEditor *p; p=(TGeoRotationEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial phi   (Euler rotation angle about Z)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial theta (Euler rotation angle about new X)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsii=",0,"Initial dz    (Euler rotation angle about new Z)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleX=",0,"New rotation angle about X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleY=",0,"New rotation angle about Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleZ=",0,"New rotation angle about Z");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotation),-1,-1,2,"fRotation=",0,"Rotation object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that this was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that this can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fRotName=",0,"Translation name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPhi=",0,"Number entry for phi angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotTheta=",0,"Number entry for theta angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPsi=",0,"Number entry for psi angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotAxis=",0,"Number entry for rotation angle about one axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotX=",0,"Rotation about X selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotY=",0,"Rotation about Y selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotZ=",0,"Rotation about Z selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCombiTransEditor */
static void G__setup_memvarTGeoCombiTransEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor));
   { TGeoCombiTransEditor *p; p=(TGeoCombiTransEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi=",0,"Initial dx");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial dy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial phi   (Euler rotation angle about Z)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial theta (Euler rotation angle about new X)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsii=",0,"Initial dz    (Euler rotation angle about new Z)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleX=",0,"New rotation angle about X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleY=",0,"New rotation angle about Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleZ=",0,"New rotation angle about Z");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTrans),-1,-1,2,"fCombi=",0,"Combi object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that this was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that this can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fRotName=",0,"Translation name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDx=",0,"Number entry for box DX");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDy=",0,"Number entry for box DY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDz=",0,"Number entry for box DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPhi=",0,"Number entry for phi angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotTheta=",0,"Number entry for theta angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPsi=",0,"Number entry for psi angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotAxis=",0,"Number entry for rotation angle about one axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotX=",0,"Rotation about X selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotY=",0,"Rotation about Y selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotZ=",0,"Rotation about Z selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoManagerEditor */
static void G__setup_memvarTGeoManagerEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor));
   { TGeoManagerEditor *p; p=(TGeoManagerEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManager),-1,-1,2,"fGeometry=",0,"Selected geometry manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager),-1,-1,2,"fTabMgr=",0,"Tab manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,2,"fTab=",0,"TGTab of GedEditor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fVolumeTab=",0,"Tab of Volume tab");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that manager was modified");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGShutter),-1,-1,2,"fCategories=",0,"Categories shutter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fManagerName=",0,"Name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fManagerTitle=",0,"Title text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMediumName=",0,"Medium name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMatrixName=",0,"Matrix name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMaterialName=",0,"Material name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fVolumeName=",0,"Volume name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fSelectedMaterial=",0,"Selected material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fSelectedMaterial2=",0,"Selected material for medium creation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMaterial=",0,"Selected material label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMaterial2=",0,"Selected material label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMaterial=",0,"Button for selecting a material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMaterial2=",0,"Button for selecting a material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedVolume=",0,"Selected volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelVolume=",0,"Selected volume label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelVolume=",0,"Button for selecting a volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShape),-1,-1,2,"fSelectedShape=",0,"Selected shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShape),-1,-1,2,"fSelectedShape2=",0,"Selected shape for volume creation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelShape=",0,"Selected shape label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelShape2=",0,"Selected shape label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelShape=",0,"Button for selecting a shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelShape2=",0,"Button for selecting a shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrix),-1,-1,2,"fSelectedMatrix=",0,"Selected matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMatrix=",0,"Selected matrix label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMatrix=",0,"Button for selecting a matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fSelectedMedium=",0,"Selected medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fSelectedMedium2=",0,"Selected medium for volume creation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMedium=",0,"Selected medium label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMedium2=",0,"Selected medium label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMedium=",0,"Button for selecting a medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMedium2=",0,"Button for selecting a medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fShapeButton[21]=",0,"List of shape buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fMatrixButton[3]=",0,"List of matrix buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fVolumeButton[2]=",0,"List of volume buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fMaterialButton[2]=",0,"List of material buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fExportOption[2]=",0,"Export option buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fExportButton=",0,"Button to export geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fElementList=",0,"Combo box for elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEntryDensity=",0,"Number entry for material density");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fMediumButton=",0,"Button to create a medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMediumId=",0,"Medium ID number entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditShape=",0,"Button for editing selected shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMedium=",0,"Button for editing a medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMaterial=",0,"Button for editing a material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMatrix=",0,"Button for editing a matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditVolume=",0,"Button for editing a volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fSetTopVolume=",0,"Button for setting top volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelTop=",0,"Selected top volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelTop=",0,"Button for selecting top volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCloseGeometry=",0,"Button for closing the geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f2=",0,"Parent frame for shape editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f3=",0,"Parent frame for volume editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f4=",0,"Parent frame for materials editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f5=",0,"Parent frame for media editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f6=",0,"Parent frame for matrices editing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f7=",0,"Parent frame for closing geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TCanvas),-1,-1,2,"fConnectedCanvas=",0,"Canvas connected to SelectedSlot()");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTubeEditor */
static void G__setup_memvarTGeoTubeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor));
   { TGeoTubeEditor *p; p=(TGeoTubeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial inner radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial outer radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial box dz");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTube),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for rmin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for rmax");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTubeSegEditor */
static void G__setup_memvarTGeoTubeSegEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor));
   { TGeoTubeSegEditor *p; p=(TGeoTubeSegEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLock=",0,"Phi lock");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmini=",0,"Initial phi min");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmaxi=",0,"Initial phi max");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSPhi=",0,"Phi slider");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi2=",0,"Number entry for phi2  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCtubEditor */
static void G__setup_memvarTGeoCtubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor));
   { TGeoCtubEditor *p; p=(TGeoCtubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThlo=",0,"Theta angle of the normal to the lower plane (90, 180)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhlo=",0,"Phi angle of the normal to lower Z plane");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThhi=",0,"Theta angle of the normal to the upper plane (0, 90)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhhi=",0,"Phi angle of the normal to upper Z plane");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEThlo=",0,"Number entry for thlo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhlo=",0,"Number entry for phlo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEThhi=",0,"Number entry for thhi");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhhi=",0,"Number entry for phhi");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoConeEditor */
static void G__setup_memvarTGeoConeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor));
   { TGeoConeEditor *p; p=(TGeoConeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini1=",0,"Initial inner radius at -dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi1=",0,"Initial outer radius at -dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini2=",0,"Initial inner radius at +dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi2=",0,"Initial outer radius at +dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial box dz");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCone),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin1=",0,"Number entry for rmin1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin2=",0,"Number entry for rmin2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax1=",0,"Number entry for rmax1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax2=",0,"Number entry for rmax2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoConeSegEditor */
static void G__setup_memvarTGeoConeSegEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor));
   { TGeoConeSegEditor *p; p=(TGeoConeSegEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLock=",0,"Phi lock");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmini=",0,"Initial phi min");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmaxi=",0,"Initial phi max");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSPhi=",0,"Phi slider");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi2=",0,"Number entry for phi2  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTrd1Editor */
static void G__setup_memvarTGeoTrd1Editor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor));
   { TGeoTrd1Editor *p; p=(TGeoTrd1Editor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi1=",0,"Initial  dx1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi2=",0,"Initial  dx2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial  dy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial  dz");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx1=",0,"Number entry for  DX1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx2=",0,"Number entry for  DX2 ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy=",0,"Number entry for  DY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for  DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTrd2Editor */
static void G__setup_memvarTGeoTrd2Editor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor));
   { TGeoTrd2Editor *p; p=(TGeoTrd2Editor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi1=",0,"Initial  dx1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi2=",0,"Initial  dx2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi1=",0,"Initial  dy1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi2=",0,"Initial  dy2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial  dz");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx1=",0,"Number entry for  DX1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx2=",0,"Number entry for  DX2 ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy1=",0,"Number entry for  DY1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy2=",0,"Number entry for  DY1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for  DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMaterialEditor */
static void G__setup_memvarTGeoMaterialEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor));
   { TGeoMaterialEditor *p; p=(TGeoMaterialEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAi=",0,"Initial atomic mass");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fZi=",0,"Initial Z");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatei=",0,"Initial material state");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDensityi=",0,"Initial density");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTempi=",0,"Initial temperature");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPresi=",0,"Initial pressure");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fMaterial=",0,"Material object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that material was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMaterialEditable=",0,"Flag that the material can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMaterialName=",0,"Material name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatA=",0,"Number entry for A");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatZ=",0,"Number entry for Z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fMatState=",0,"Material state");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatDensity=",0,"Number entry for density");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatTemperature=",0,"Number entry for temperature");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatPressure=",0,"Number entry for pressure");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatRadLen=",0,"Number entry for radiation length");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatAbsLen=",0,"Number entry for absorbtion length");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f23=",0,"Frame for buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMixtureEditor */
static void G__setup_memvarTGeoMixtureEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor));
   { TGeoMixtureEditor *p; p=(TGeoMixtureEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixture),-1,-1,2,"fMixture=",0,"Mixture object ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fMixElem=",0,"Combo box for elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fNelem=",0,"Label for number of elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fAelem=",0,"Label for A");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fZelem=",0,"Label for Z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fChkFraction=",0,"Check button for fraction by wght.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fNEFraction=",0,"Number entry for fraction value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fChkNatoms=",0,"Check button for number of atoms");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fNENatoms=",0,"Number entry for number of atoms");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fBAddElem=",0,"Buttom for adding element as component");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fComps=",0,"Frame with components");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTreeDialog */
static void G__setup_memvarTGeoTreeDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog));
   { TGeoTreeDialog *p; p=(TGeoTreeDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),-1,-2,2,"fgSelectedObj=",0,"Selected object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCanvas),-1,-1,2,"fCanvas=",0,"TGCanvas containing the list tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fObjLabel=",0,"Label for selected object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGListTree),-1,-1,2,"fLT=",0,"List tree for selecting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f1=",0,"Composite frame containing the selection");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fClose=",0,"Close button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTransientPanel */
static void G__setup_memvarTGeoTransientPanel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel));
   { TGeoTransientPanel *p; p=(TGeoTransientPanel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedEditor),-1,-1,4,"fGedEditor=",0,"ged-editor steering this panel");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCanvas),-1,-1,4,"fCan=",0,"TGCanvas containing a TGTab");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,4,"fTab=",0,"tab widget holding the editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,4,"fTabContainer=",0,"main tab container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,4,"fStyle=",0,"style tab container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),-1,-1,4,"fModel=",0,"selected object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,4,"fClose=",0,"close button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoVolumeDialog */
static void G__setup_memvarTGeoVolumeDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog));
   { TGeoVolumeDialog *p; p=(TGeoVolumeDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoShapeDialog */
static void G__setup_memvarTGeoShapeDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog));
   { TGeoShapeDialog *p; p=(TGeoShapeDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMediumDialog */
static void G__setup_memvarTGeoMediumDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog));
   { TGeoMediumDialog *p; p=(TGeoMediumDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMaterialDialog */
static void G__setup_memvarTGeoMaterialDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog));
   { TGeoMaterialDialog *p; p=(TGeoMaterialDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMatrixDialog */
static void G__setup_memvarTGeoMatrixDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog));
   { TGeoMatrixDialog *p; p=(TGeoMatrixDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoSphereEditor */
static void G__setup_memvarTGeoSphereEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor));
   { TGeoSphereEditor *p; p=(TGeoSphereEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial inner radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial outer radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta1i=",0,"Initial lower theta limit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta2i=",0,"Initial higher theta limit   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1i=",0,"Initial lower phi limit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2i=",0,"Initial higher phi limit   ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphere),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLock=",0,"Lock");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for rmin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for rmax");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta1=",0,"Number entry for Theta1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta2=",0,"Number entry for Theta2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi2=",0,"Number entry for phi2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSPhi=",0,"Phi slider");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSTheta=",0,"Theta slider  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPconSection */
static void G__setup_memvarTGeoPconSection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection));
   { TGeoPconSection *p; p=(TGeoPconSection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"Id for the section");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEZ=",0,"Number entry for Z position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for Rmin position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for Rmax position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPconEditor */
static void G__setup_memvarTGeoPconEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor));
   { TGeoPconEditor *p; p=(TGeoPconEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsecti=",0,"Initial number of sections");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1i=",0,"Initial Phi1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDPhii=",0,"Initial Dphi");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZi=",0,"Initial Z positions");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial Rmin values");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial Rmax values   ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsections=",0,"Number of Z sections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TObjArray),-1,-1,2,"fSections=",0,"List of section frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCanvas),-1,-1,2,"fCan=",0,"sections container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPcon),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLayoutHints),-1,-1,2,"fLHsect=",0,"Layout hints for sections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fENz=",0,"Number entry for nsections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDPhi=",0,"Number entry for dphi  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoParaEditor */
static void G__setup_memvarTGeoParaEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor));
   { TGeoParaEditor *p; p=(TGeoParaEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXi=",0,"Initial  X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYi=",0,"Initial  Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZi=",0,"Initial  Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlphai=",0,"Initial  alpha");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial  theta");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial  phi");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPara),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx=",0,"Number entry for  DX2 ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy=",0,"Number entry for  DY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for  DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEAlpha=",0,"Number entry for  Alpha");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta=",0,"Number entry for  Theta ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi=",0,"Number entry for  Theta ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTorusEditor */
static void G__setup_memvarTGeoTorusEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor));
   { TGeoTorusEditor *p; p=(TGeoTorusEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRi=",0,"Initial  axial radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial  inner radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial  outer radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1i=",0,"Initial  starting phi1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDphii=",0,"Initial  phi extent");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorus),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fER=",0,"Number entry for  R");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for  Rmin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for  Rmax");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for  phi1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDphi=",0,"Number entry for  Dphi ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoEltuEditor */
static void G__setup_memvarTGeoEltuEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor));
   { TGeoEltuEditor *p; p=(TGeoEltuEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAi=",0,"Initial  semi-axis of the ellipse along x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBi=",0,"Initial  semi-axis of the ellipse along y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial  half length in z");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltu),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEA=",0,"Number entry for  A");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEB=",0,"Number entry for  B");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for  DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoHypeEditor */
static void G__setup_memvarTGeoHypeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor));
   { TGeoHypeEditor *p; p=(TGeoHypeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRini=",0,"Initial  inner radius ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRouti=",0,"Initial  outer radius ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial  half length Dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStIni=",0,"Initial  stereo angle for inner surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStOuti=",0,"Initial  stereo angle for outer surface");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHype),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERin=",0,"Number entry for  Rin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERout=",0,"Number entry for  Rout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for  Dz");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEStIn=",0,"Number entry for  StIn");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEStOut=",0,"Number entry for  StOut");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPgonEditor */
static void G__setup_memvarTGeoPgonEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor));
   { TGeoPgonEditor *p; p=(TGeoPgonEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNedgesi=",0,"Initial number of edges");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fENedges=",0,"Number entry for nsections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTrapEditor */
static void G__setup_memvarTGeoTrapEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor));
   { TGeoTrapEditor *p; p=(TGeoTrapEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH1i=",0,"Initial half length in y at low z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBl1i=",0,"Initial  half length in x at low z and y low edge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTl1i=",0,"Initial  half length in x at low z and y high edge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial  Dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSci=",0,"Initial  scale factor for upper face");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha1i=",0,"Initial  angle between centers of x edges an y axis at low z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial  theta");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial  phi");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrap),-1,-1,2,"fShape=",0,"Shape object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEH1=",0,"Number entry for  H1 ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEBl1=",0,"Number entry for  Bl1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETl1=",0,"Number entry for  Tl1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fESc1=",0,"Number entry for lower scale");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fESc2=",0,"Number entry for  upper scale");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for  DZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEAlpha1=",0,"Number entry for  Alpha1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta=",0,"Number entry for  Theta ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi=",0,"Number entry for  Theta ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoGtraEditor */
static void G__setup_memvarTGeoGtraEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor));
   { TGeoGtraEditor *p; p=(TGeoGtraEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTwisti=",0,"Initial twist angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETwist=",0,"Number entry for  H1 ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__GeomBuilder() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTGeoTabManager(void) {
   /* TGeoTabManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager));
   G__memfunc_setup("GetEditors",1018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTabManager",1345,G__G__GeomBuilder_258_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager), -1, 0, 1, 1, 1, 0, "U 'TGedEditor' - 0 - ged", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeTabManager",1648,G__G__GeomBuilder_258_0_3, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager), -1, 0, 1, 3, 1, 0, "U 'TGedEditor' - 0 - ged", (char*)NULL, (void*) G__func2void( (TGeoTabManager* (*)(TGedEditor*))(&TGeoTabManager::GetMakeTabManager) ), 0);
   G__memfunc_setup("Cleanup",712,G__G__GeomBuilder_258_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TGCompositeFrame' - 0 - frame", (char*)NULL, (void*) G__func2void( (void (*)(TGCompositeFrame*))(&TGeoTabManager::Cleanup) ), 0);
   G__memfunc_setup("GetPad",565,G__G__GeomBuilder_258_0_5, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTab",567,G__G__GeomBuilder_258_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabIndex",1071,G__G__GeomBuilder_258_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveFrame",898,G__G__GeomBuilder_258_0_8, 121, -1, -1, 0, 2, 3, 1, 0, 
"U 'TGCompositeFrame' - 0 - fr U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) G__func2void( (void (*)(TGCompositeFrame*, TGCompositeFrame*))(&TGeoTabManager::MoveFrame) ), 0);
   G__memfunc_setup("SetVolTabEnabled",1567,G__G__GeomBuilder_258_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__GeomBuilder_258_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTab",579,G__G__GeomBuilder_258_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShapeEditor",1400,G__G__GeomBuilder_258_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolumeEditor",1535,G__G__GeomBuilder_258_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixEditor",1532,G__G__GeomBuilder_258_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 0 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMediumEditor",1512,G__G__GeomBuilder_258_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMedium' - 0 - medium", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaterialEditor",1718,G__G__GeomBuilder_258_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMaterial' - 0 - material", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolumeTab",1199,G__G__GeomBuilder_258_0_17, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__GeomBuilder_258_0_18, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_258_0_19, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTabManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_258_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTabManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_258_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTabManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_258_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTabManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_258_0_26, 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__GeomBuilder_258_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTabManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_258_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTabManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_258_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTabManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_258_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTabManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTabManager", 1471, G__G__GeomBuilder_258_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoGedFrame(void) {
   /* TGeoGedFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame));
   G__memfunc_setup("SetActive",904,G__G__GeomBuilder_259_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' active", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_259_0_4, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGedFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_259_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGedFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_259_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGedFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_259_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGedFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_259_0_11, 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__GeomBuilder_259_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGedFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_259_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGedFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_259_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGedFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_259_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGedFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoGedFrame", 1256, G__G__GeomBuilder_259_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoVolumeEditor(void) {
   /* TGeoVolumeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor));
   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("TGeoVolumeEditor",1614,G__G__GeomBuilder_274_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor), -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("DoAddNode",834,G__G__GeomBuilder_274_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVolumeName",1196,G__G__GeomBuilder_274_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectShape",1284,G__G__GeomBuilder_274_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMedium",1396,G__G__GeomBuilder_274_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMatrix",1416,G__G__GeomBuilder_274_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectVolume",1419,G__G__GeomBuilder_274_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditShape",1066,G__G__GeomBuilder_274_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditMedium",1178,G__G__GeomBuilder_274_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditMatrix",1198,G__G__GeomBuilder_274_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRemoveNode",1191,G__G__GeomBuilder_274_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVisVolume",1117,G__G__GeomBuilder_274_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVisDaughters",1420,G__G__GeomBuilder_274_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVisAuto",894,G__G__GeomBuilder_274_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVisLevel",989,G__G__GeomBuilder_274_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoViewAll",871,G__G__GeomBuilder_274_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoViewLeaves",1198,G__G__GeomBuilder_274_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoViewOnly",1008,G__G__GeomBuilder_274_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDivSelAxis",1167,G__G__GeomBuilder_274_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDivFromTo",1069,G__G__GeomBuilder_274_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDivStep",882,G__G__GeomBuilder_274_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDivN",548,G__G__GeomBuilder_274_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDivName",855,G__G__GeomBuilder_274_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApplyDiv",988,G__G__GeomBuilder_274_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRaytrace",1006,G__G__GeomBuilder_274_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_274_0_29, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolumeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_274_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_274_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolumeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_274_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolumeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_274_0_36, 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__GeomBuilder_274_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_274_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_274_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_274_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolumeEditor", 1740, G__G__GeomBuilder_274_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoBBoxEditor(void) {
   /* TGeoBBoxEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBBoxEditor",1345,G__G__GeomBuilder_276_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor), -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("DoDx",367,G__G__GeomBuilder_276_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDy",368,G__G__GeomBuilder_276_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_276_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOx",378,G__G__GeomBuilder_276_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOy",379,G__G__GeomBuilder_276_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOz",380,G__G__GeomBuilder_276_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_276_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_276_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_276_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_276_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_276_0_15, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoBBoxEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_276_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBoxEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_276_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoBBoxEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_276_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoBBoxEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_276_0_22, 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__GeomBuilder_276_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBoxEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_276_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBBoxEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_276_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBoxEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_276_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBBoxEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoBBoxEditor", 1471, G__G__GeomBuilder_276_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMediumEditor(void) {
   /* TGeoMediumEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor));
   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("TGeoMediumEditor",1591,G__G__GeomBuilder_277_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor), -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("DoEditMaterial",1384,G__G__GeomBuilder_277_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMaterial",1602,G__G__GeomBuilder_277_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMedName",842,G__G__GeomBuilder_277_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMedId",630,G__G__GeomBuilder_277_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoToggleSensitive",1743,G__G__GeomBuilder_277_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMagfldSelect",1374,G__G__GeomBuilder_277_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ientry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFieldm",772,G__G__GeomBuilder_277_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTmaxfd",791,G__G__GeomBuilder_277_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoStemax",805,G__G__GeomBuilder_277_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDeemax",775,G__G__GeomBuilder_277_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEpsil",688,G__G__GeomBuilder_277_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoStmin",702,G__G__GeomBuilder_277_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_277_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_277_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_277_0_18, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMediumEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_277_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_277_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMediumEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_277_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMediumEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_277_0_25, 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__GeomBuilder_277_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_277_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_277_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_277_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMediumEditor", 1717, G__G__GeomBuilder_277_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoNodeEditor(void) {
   /* TGeoNodeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor));
   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("TGeoNodeEditor",1372,G__G__GeomBuilder_279_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor), -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("DoEditMother",1192,G__G__GeomBuilder_279_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditVolume",1201,G__G__GeomBuilder_279_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditMatrix",1198,G__G__GeomBuilder_279_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMother",1410,G__G__GeomBuilder_279_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectVolume",1419,G__G__GeomBuilder_279_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMatrix",1416,G__G__GeomBuilder_279_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoNodeName",954,G__G__GeomBuilder_279_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoNodeNumber",1186,G__G__GeomBuilder_279_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_279_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_279_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_279_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNodeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_279_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_279_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNodeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_279_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNodeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_279_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__GeomBuilder_279_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_279_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_279_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_279_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoNodeEditor", 1498, G__G__GeomBuilder_279_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTranslationEditor(void) {
   /* TGeoTranslationEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor));
   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("TGeoTranslationEditor",2149,G__G__GeomBuilder_283_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor), -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("DoDx",367,G__G__GeomBuilder_283_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDy",368,G__G__GeomBuilder_283_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_283_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_283_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_283_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoParameters",1223,G__G__GeomBuilder_283_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_283_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCancel",761,G__G__GeomBuilder_283_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_283_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_283_0_13, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTranslationEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_283_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslationEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_283_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTranslationEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_283_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTranslationEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_283_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__GeomBuilder_283_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslationEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_283_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTranslationEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_283_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslationEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_283_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTranslationEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTranslationEditor", 2275, G__G__GeomBuilder_283_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoRotationEditor(void) {
   /* TGeoRotationEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor));
   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("TGeoRotationEditor",1830,G__G__GeomBuilder_284_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor), -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("DoRotPhi",777,G__G__GeomBuilder_284_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotTheta",990,G__G__GeomBuilder_284_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotPsi",788,G__G__GeomBuilder_284_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotAngle",975,G__G__GeomBuilder_284_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_284_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_284_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoParameters",1223,G__G__GeomBuilder_284_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_284_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCancel",761,G__G__GeomBuilder_284_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_284_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_284_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoRotationEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_284_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotationEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_284_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoRotationEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_284_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoRotationEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_284_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__GeomBuilder_284_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotationEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_284_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoRotationEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_284_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotationEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_284_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoRotationEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoRotationEditor", 1956, G__G__GeomBuilder_284_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCombiTransEditor(void) {
   /* TGeoCombiTransEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor));
   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("TGeoCombiTransEditor",1992,G__G__GeomBuilder_285_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor), -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("DoDx",367,G__G__GeomBuilder_285_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDy",368,G__G__GeomBuilder_285_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_285_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotPhi",777,G__G__GeomBuilder_285_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotTheta",990,G__G__GeomBuilder_285_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotPsi",788,G__G__GeomBuilder_285_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotAngle",975,G__G__GeomBuilder_285_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_285_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_285_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoParameters",1223,G__G__GeomBuilder_285_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_285_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCancel",761,G__G__GeomBuilder_285_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_285_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_285_0_17, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCombiTransEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_285_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTransEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_285_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCombiTransEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_285_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCombiTransEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_285_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__GeomBuilder_285_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTransEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_285_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCombiTransEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_285_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTransEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_285_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCombiTransEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoCombiTransEditor", 2118, G__G__GeomBuilder_285_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoManagerEditor(void) {
   /* TGeoManagerEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor));
   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("ShowSelectShape",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowSelectVolume",1657,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowSelectMaterial",1840,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowSelectMedium",1634,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowSelectMatrix",1654,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoManagerEditor",1681,G__G__GeomBuilder_286_0_7, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor), -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("LoadLib",663,G__G__GeomBuilder_286_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManagerEditor::LoadLib) ), 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("SelectedSlot",1227,G__G__GeomBuilder_286_0_10, 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("ConnectSelected",1523,G__G__GeomBuilder_286_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisconnectSelected",1843,G__G__GeomBuilder_286_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_286_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateBox",1072,G__G__GeomBuilder_286_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreatePara",1163,G__G__GeomBuilder_286_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTrd1",1122,G__G__GeomBuilder_286_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTrd2",1123,G__G__GeomBuilder_286_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTrap",1182,G__G__GeomBuilder_286_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateGtra",1173,G__G__GeomBuilder_286_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateXtru",1210,G__G__GeomBuilder_286_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateArb8",1108,G__G__GeomBuilder_286_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTube",1175,G__G__GeomBuilder_286_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTubs",1189,G__G__GeomBuilder_286_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateCone",1164,G__G__GeomBuilder_286_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateCons",1178,G__G__GeomBuilder_286_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateSphe",1175,G__G__GeomBuilder_286_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateCtub",1173,G__G__GeomBuilder_286_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateEltu",1185,G__G__GeomBuilder_286_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTorus",1316,G__G__GeomBuilder_286_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreatePcon",1175,G__G__GeomBuilder_286_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreatePgon",1179,G__G__GeomBuilder_286_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateHype",1181,G__G__GeomBuilder_286_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateParab",1261,G__G__GeomBuilder_286_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateComposite",1722,G__G__GeomBuilder_286_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateMaterial",1590,G__G__GeomBuilder_286_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateMixture",1525,G__G__GeomBuilder_286_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateMedium",1384,G__G__GeomBuilder_286_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateTranslation",1942,G__G__GeomBuilder_286_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateRotation",1623,G__G__GeomBuilder_286_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateCombi",1265,G__G__GeomBuilder_286_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateVolume",1407,G__G__GeomBuilder_286_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCreateAssembly",1607,G__G__GeomBuilder_286_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditShape",1066,G__G__GeomBuilder_286_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditVolume",1201,G__G__GeomBuilder_286_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditMedium",1178,G__G__GeomBuilder_286_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditMaterial",1384,G__G__GeomBuilder_286_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditMatrix",1198,G__G__GeomBuilder_286_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectShape",1284,G__G__GeomBuilder_286_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectShape2",1334,G__G__GeomBuilder_286_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectVolume",1419,G__G__GeomBuilder_286_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMatrix",1416,G__G__GeomBuilder_286_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMaterial",1602,G__G__GeomBuilder_286_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMaterial2",1652,G__G__GeomBuilder_286_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMedium",1396,G__G__GeomBuilder_286_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectMedium2",1446,G__G__GeomBuilder_286_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSetTopVolume",1418,G__G__GeomBuilder_286_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectTopVolume",1726,G__G__GeomBuilder_286_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoExportGeometry",1665,G__G__GeomBuilder_286_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCloseGeometry",1525,G__G__GeomBuilder_286_0_59, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_286_0_60, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoManagerEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_286_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManagerEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_286_0_62, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoManagerEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_286_0_63, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManagerEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_286_0_67, 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__GeomBuilder_286_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManagerEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_286_0_69, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoManagerEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_286_0_70, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManagerEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_286_0_71, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoManagerEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoManagerEditor", 1807, G__G__GeomBuilder_286_0_72, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTubeEditor(void) {
   /* TGeoTubeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTubeEditor",1382,G__G__GeomBuilder_288_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor), -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("DoRmin",585,G__G__GeomBuilder_288_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_288_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_288_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_288_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_288_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_288_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_288_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_288_0_12, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTubeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_288_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_288_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTubeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_288_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTubeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_288_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__GeomBuilder_288_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_288_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_288_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_288_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTubeEditor", 1508, G__G__GeomBuilder_288_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTubeSegEditor(void) {
   /* TGeoTubeSegEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor));
   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("TGeoTubeSegEditor",1669,G__G__GeomBuilder_290_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor), -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("DoPhi",468,G__G__GeomBuilder_290_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_290_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi2",518,G__G__GeomBuilder_290_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_290_0_9, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTubeSegEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_290_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSegEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_290_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTubeSegEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_290_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTubeSegEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_290_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__GeomBuilder_290_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSegEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_290_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeSegEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_290_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSegEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_290_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeSegEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTubeSegEditor", 1795, G__G__GeomBuilder_290_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCtubEditor(void) {
   /* TGeoCtubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor));
   G__memfunc_setup("TGeoCtubEditor",1380,G__G__GeomBuilder_291_0_1, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor), -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("DoThlo",586,G__G__GeomBuilder_291_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhlo",582,G__G__GeomBuilder_291_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoThhi",576,G__G__GeomBuilder_291_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhhi",572,G__G__GeomBuilder_291_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_291_0_9, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCtubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_291_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_291_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCtubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_291_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCtubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_291_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__GeomBuilder_291_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_291_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCtubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_291_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_291_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCtubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoCtubEditor", 1506, G__G__GeomBuilder_291_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoConeEditor(void) {
   /* TGeoConeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoConeEditor",1371,G__G__GeomBuilder_294_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor), -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("DoRmin1",634,G__G__GeomBuilder_294_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmin2",635,G__G__GeomBuilder_294_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmax1",636,G__G__GeomBuilder_294_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmax2",637,G__G__GeomBuilder_294_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_294_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_294_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_294_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_294_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_294_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_294_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoConeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_294_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_294_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoConeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_294_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoConeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_294_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__GeomBuilder_294_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_294_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_294_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_294_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoConeEditor", 1497, G__G__GeomBuilder_294_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoConeSegEditor(void) {
   /* TGeoConeSegEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor));
   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("TGeoConeSegEditor",1658,G__G__GeomBuilder_295_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor), -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("DoPhi",468,G__G__GeomBuilder_295_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_295_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi2",518,G__G__GeomBuilder_295_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_295_0_9, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoConeSegEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_295_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSegEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_295_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoConeSegEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_295_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoConeSegEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_295_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__GeomBuilder_295_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSegEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_295_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeSegEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_295_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSegEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_295_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeSegEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoConeSegEditor", 1784, G__G__GeomBuilder_295_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTrd1Editor(void) {
   /* TGeoTrd1Editor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd1Editor",1329,G__G__GeomBuilder_297_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor), -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("DoDx1",416,G__G__GeomBuilder_297_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDx2",417,G__G__GeomBuilder_297_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDy",368,G__G__GeomBuilder_297_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_297_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_297_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_297_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_297_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_297_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_297_0_13, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrd1Editor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_297_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1Editor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_297_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrd1Editor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_297_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrd1Editor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_297_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__GeomBuilder_297_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1Editor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_297_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd1Editor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_297_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1Editor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_297_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd1Editor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTrd1Editor", 1455, G__G__GeomBuilder_297_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTrd2Editor(void) {
   /* TGeoTrd2Editor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd2Editor",1330,G__G__GeomBuilder_299_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor), -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("DoDx1",416,G__G__GeomBuilder_299_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDx2",417,G__G__GeomBuilder_299_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDy1",417,G__G__GeomBuilder_299_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDy2",418,G__G__GeomBuilder_299_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_299_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_299_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_299_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_299_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_299_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_299_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrd2Editor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_299_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2Editor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_299_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrd2Editor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_299_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrd2Editor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_299_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__GeomBuilder_299_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2Editor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_299_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd2Editor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_299_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2Editor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_299_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd2Editor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTrd2Editor", 1456, G__G__GeomBuilder_299_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMaterialEditor(void) {
   /* TGeoMaterialEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor));
   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("TGeoMaterialEditor",1797,G__G__GeomBuilder_301_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor), -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("DoA",244,G__G__GeomBuilder_301_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoZ",269,G__G__GeomBuilder_301_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDensity",915,G__G__GeomBuilder_301_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_301_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_301_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRadAbs",736,G__G__GeomBuilder_301_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoState",692,G__G__GeomBuilder_301_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTemperature",1345,G__G__GeomBuilder_301_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPressure",1036,G__G__GeomBuilder_301_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_301_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_301_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_301_0_15, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMaterialEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_301_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_301_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMaterialEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_301_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMaterialEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_301_0_22, 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__GeomBuilder_301_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_301_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_301_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_301_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMaterialEditor", 1923, G__G__GeomBuilder_301_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMixtureEditor(void) {
   /* TGeoMixtureEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor));
   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("TGeoMixtureEditor",1732,G__G__GeomBuilder_303_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor), -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("UpdateElements",1440,G__G__GeomBuilder_303_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply1",746,G__G__GeomBuilder_303_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo1",634,G__G__GeomBuilder_303_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoChkFraction",1279,G__G__GeomBuilder_303_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoChkNatoms",1083,G__G__GeomBuilder_303_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFraction",1001,G__G__GeomBuilder_303_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoNatoms",805,G__G__GeomBuilder_303_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSelectElement",1501,G__G__GeomBuilder_303_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - iel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAddElem",831,G__G__GeomBuilder_303_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_303_0_13, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMixtureEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_303_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixtureEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_303_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMixtureEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_303_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMixtureEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_303_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__GeomBuilder_303_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixtureEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_303_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMixtureEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_303_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixtureEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_303_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMixtureEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMixtureEditor", 1858, G__G__GeomBuilder_303_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTreeDialog(void) {
   /* TGeoTreeDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog));
   G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSelected",1097,G__G__GeomBuilder_311_0_4, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObject* (*)())(&TGeoTreeDialog::GetSelected) ), 0);
   G__memfunc_setup("DoClose",681,G__G__GeomBuilder_311_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DoItemClick",1064,G__G__GeomBuilder_311_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DoSelect",787,G__G__GeomBuilder_311_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_311_0_8, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTreeDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_311_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTreeDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_311_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTreeDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_311_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTreeDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_311_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__GeomBuilder_311_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTreeDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_311_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTreeDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_311_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTreeDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_311_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTreeDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTreeDialog", 1485, G__G__GeomBuilder_311_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTransientPanel(void) {
   /* TGeoTransientPanel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel));
   G__memfunc_setup("TGeoTransientPanel",1815,G__G__GeomBuilder_312_0_1, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel), -1, 0, 3, 1, 1, 0, 
"U 'TGedEditor' - 0 - ged C - - 10 - name "
"U 'TObject' - 0 - obj", (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("DeleteEditors",1325,G__G__GeomBuilder_312_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTab",567,G__G__GeomBuilder_312_0_4, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStyle",817,G__G__GeomBuilder_312_0_5, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetModel",785,G__G__GeomBuilder_312_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditors",1018,G__G__GeomBuilder_312_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hide",378,G__G__GeomBuilder_312_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__GeomBuilder_312_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,G__G__GeomBuilder_312_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_312_0_11, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTransientPanel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_312_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTransientPanel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_312_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTransientPanel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_312_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTransientPanel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_312_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__GeomBuilder_312_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTransientPanel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_312_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTransientPanel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_312_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTransientPanel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_312_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTransientPanel::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTransientPanel", 1941, G__G__GeomBuilder_312_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoVolumeDialog(void) {
   /* TGeoVolumeDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog));
   G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoVolumeDialog",1591,G__G__GeomBuilder_313_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_313_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolumeDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_313_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_313_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolumeDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_313_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolumeDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_313_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__GeomBuilder_313_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_313_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_313_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_313_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolumeDialog", 1717, G__G__GeomBuilder_313_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoShapeDialog(void) {
   /* TGeoShapeDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog));
   G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoShapeDialog",1456,G__G__GeomBuilder_314_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_314_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoShapeDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_314_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_314_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoShapeDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_314_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoShapeDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_314_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__GeomBuilder_314_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_314_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShapeDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_314_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_314_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShapeDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoShapeDialog", 1582, G__G__GeomBuilder_314_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMediumDialog(void) {
   /* TGeoMediumDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog));
   G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoMediumDialog",1568,G__G__GeomBuilder_315_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_315_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMediumDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_315_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_315_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMediumDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_315_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMediumDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_315_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__GeomBuilder_315_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_315_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_315_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_315_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMediumDialog", 1694, G__G__GeomBuilder_315_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMaterialDialog(void) {
   /* TGeoMaterialDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog));
   G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoMaterialDialog",1774,G__G__GeomBuilder_316_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_316_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMaterialDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_316_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_316_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMaterialDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_316_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMaterialDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_316_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__GeomBuilder_316_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_316_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_316_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_316_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMaterialDialog", 1900, G__G__GeomBuilder_316_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMatrixDialog(void) {
   /* TGeoMatrixDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog));
   G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoMatrixDialog",1588,G__G__GeomBuilder_317_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_317_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMatrixDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_317_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrixDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_317_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMatrixDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_317_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMatrixDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_317_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__GeomBuilder_317_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrixDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_317_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMatrixDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_317_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrixDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_317_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMatrixDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMatrixDialog", 1714, G__G__GeomBuilder_317_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoSphereEditor(void) {
   /* TGeoSphereEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoSphereEditor",1597,G__G__GeomBuilder_319_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor), -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("DoRmin",585,G__G__GeomBuilder_319_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_319_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_319_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTheta",681,G__G__GeomBuilder_319_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTheta1",730,G__G__GeomBuilder_319_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTheta2",731,G__G__GeomBuilder_319_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_319_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi2",518,G__G__GeomBuilder_319_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_319_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_319_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_319_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_319_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_319_0_17, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoSphereEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_319_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphereEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_319_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoSphereEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_319_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoSphereEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_319_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__GeomBuilder_319_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphereEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_319_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSphereEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_319_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphereEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_319_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSphereEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoSphereEditor", 1723, G__G__GeomBuilder_319_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPconSection(void) {
   /* TGeoPconSection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoPconSection",1492,G__G__GeomBuilder_321_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideDaughters",1313,G__G__GeomBuilder_321_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__GeomBuilder_321_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmin",694,G__G__GeomBuilder_321_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmax",696,G__G__GeomBuilder_321_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__G__GeomBuilder_321_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRmin",706,G__G__GeomBuilder_321_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRmax",708,G__G__GeomBuilder_321_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoZ",269,G__G__GeomBuilder_321_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmin",585,G__G__GeomBuilder_321_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_321_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Changed",682,G__G__GeomBuilder_321_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_321_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPconSection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_321_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconSection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_321_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPconSection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_321_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPconSection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_321_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__GeomBuilder_321_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconSection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_321_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconSection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_321_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconSection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_321_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconSection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPconSection", 1618, G__G__GeomBuilder_321_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPconEditor(void) {
   /* TGeoPconEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor));
   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("CheckSections",1318,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kFALSE' change", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateSections",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - inew", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateSections",1451,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateEdges",1084,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoPconEditor",1382,G__G__GeomBuilder_322_0_7, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor), -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("DoModified",980,G__G__GeomBuilder_322_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_322_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoNz",379,G__G__GeomBuilder_322_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_322_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSectionChange",1486,G__G__GeomBuilder_322_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_322_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_322_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_322_0_16, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPconEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_322_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_322_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPconEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_322_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPconEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_322_0_23, 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__GeomBuilder_322_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_322_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_322_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_322_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPconEditor", 1508, G__G__GeomBuilder_322_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoParaEditor(void) {
   /* TGeoParaEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoParaEditor",1370,G__G__GeomBuilder_324_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor), -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("DoX",267,G__G__GeomBuilder_324_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoY",268,G__G__GeomBuilder_324_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoZ",269,G__G__GeomBuilder_324_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAlpha",665,G__G__GeomBuilder_324_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTheta",681,G__G__GeomBuilder_324_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_324_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_324_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_324_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_324_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_324_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_324_0_15, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoParaEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_324_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_324_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoParaEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_324_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoParaEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_324_0_22, 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__GeomBuilder_324_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_324_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoParaEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_324_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_324_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoParaEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoParaEditor", 1496, G__G__GeomBuilder_324_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTorusEditor(void) {
   /* TGeoTorusEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTorusEditor",1523,G__G__GeomBuilder_326_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor), -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("DoR",261,G__G__GeomBuilder_326_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmin",585,G__G__GeomBuilder_326_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_326_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_326_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDphi",568,G__G__GeomBuilder_326_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_326_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_326_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_326_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_326_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_326_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTorusEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_326_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorusEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_326_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTorusEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_326_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTorusEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_326_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__GeomBuilder_326_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorusEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_326_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTorusEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_326_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorusEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_326_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTorusEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTorusEditor", 1649, G__G__GeomBuilder_326_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoEltuEditor(void) {
   /* TGeoEltuEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoEltuEditor",1392,G__G__GeomBuilder_328_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor), -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("DoA",244,G__G__GeomBuilder_328_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoB",245,G__G__GeomBuilder_328_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_328_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_328_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_328_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_328_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_328_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_328_0_12, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoEltuEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_328_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltuEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_328_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoEltuEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_328_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoEltuEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_328_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__GeomBuilder_328_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltuEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_328_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoEltuEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_328_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltuEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_328_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoEltuEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoEltuEditor", 1518, G__G__GeomBuilder_328_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoHypeEditor(void) {
   /* TGeoHypeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHypeEditor",1388,G__G__GeomBuilder_330_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor), -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("DoRin",476,G__G__GeomBuilder_330_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRout",605,G__G__GeomBuilder_330_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_330_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoStIn",561,G__G__GeomBuilder_330_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoStOut",690,G__G__GeomBuilder_330_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_330_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_330_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_330_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_330_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_330_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoHypeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_330_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHypeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_330_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoHypeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_330_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoHypeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_330_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__GeomBuilder_330_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHypeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_330_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHypeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_330_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHypeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_330_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHypeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoHypeEditor", 1514, G__G__GeomBuilder_330_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPgonEditor(void) {
   /* TGeoPgonEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor));
   G__memfunc_setup("CreateEdges",1084,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGeoPgonEditor",1386,G__G__GeomBuilder_331_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor), -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("DoNedges",777,G__G__GeomBuilder_331_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_331_0_7, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPgonEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_331_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgonEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_331_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPgonEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_331_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPgonEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_331_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__GeomBuilder_331_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgonEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_331_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPgonEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_331_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgonEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_331_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPgonEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPgonEditor", 1512, G__G__GeomBuilder_331_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTrapEditor(void) {
   /* TGeoTrapEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor));
   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("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrapEditor",1389,G__G__GeomBuilder_333_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor), -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("DoH1",300,G__G__GeomBuilder_333_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoBl1",402,G__G__GeomBuilder_333_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTl1",420,G__G__GeomBuilder_333_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDz",369,G__G__GeomBuilder_333_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSc1",410,G__G__GeomBuilder_333_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSc2",411,G__G__GeomBuilder_333_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAlpha1",714,G__G__GeomBuilder_333_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTheta",681,G__G__GeomBuilder_333_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_333_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModified",980,G__G__GeomBuilder_333_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoName",564,G__G__GeomBuilder_333_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,G__G__GeomBuilder_333_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_333_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_333_0_18, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrapEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_333_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrapEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_333_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrapEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_333_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrapEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_333_0_25, 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__GeomBuilder_333_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrapEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_333_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrapEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_333_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrapEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_333_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrapEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTrapEditor", 1515, G__G__GeomBuilder_333_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoGtraEditor(void) {
   /* TGeoGtraEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor));
   G__memfunc_setup("TGeoGtraEditor",1380,G__G__GeomBuilder_334_0_1, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor), -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("DoTwist",718,G__G__GeomBuilder_334_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GeomBuilder_334_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGtraEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_334_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtraEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_334_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGtraEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_334_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGtraEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_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__GeomBuilder_334_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__GeomBuilder_334_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtraEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_334_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGtraEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_334_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtraEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_334_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGtraEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoGtraEditor", 1506, G__G__GeomBuilder_334_0_18, (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__GeomBuilder() {
}

/*********************************************************
* 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__GeomBuilder() {
  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__GeomBuilder() {
  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__GeomBuilderLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGWidget = { "TGWidget" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_pairlEunsignedsPintcOintgR = { "pair<unsigned int,int>" , 115 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR = { "vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGTab = { "TGTab" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGedEditor = { "TGedEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGedFrame = { "TGedFrame" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTabManager = { "TGeoTabManager" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoGedFrame = { "TGeoGedFrame" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoManager = { "TGeoManager" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoShape = { "TGeoShape" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMedium = { "TGeoMedium" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMaterial = { "TGeoMaterial" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGShutter = { "TGShutter" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoVolumeEditor = { "TGeoVolumeEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoBBox = { "TGeoBBox" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoBBoxEditor = { "TGeoBBoxEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMediumEditor = { "TGeoMediumEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoNode = { "TGeoNode" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoNodeEditor = { "TGeoNodeEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTranslation = { "TGeoTranslation" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoRotation = { "TGeoRotation" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoCombiTrans = { "TGeoCombiTrans" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTranslationEditor = { "TGeoTranslationEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoRotationEditor = { "TGeoRotationEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoCombiTransEditor = { "TGeoCombiTransEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoManagerEditor = { "TGeoManagerEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTube = { "TGeoTube" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTubeEditor = { "TGeoTubeEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGDoubleVSlider = { "TGDoubleVSlider" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTubeSegEditor = { "TGeoTubeSegEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoCtubEditor = { "TGeoCtubEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoCone = { "TGeoCone" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoConeEditor = { "TGeoConeEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoConeSegEditor = { "TGeoConeSegEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd1 = { "TGeoTrd1" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd1Editor = { "TGeoTrd1Editor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd2 = { "TGeoTrd2" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd2Editor = { "TGeoTrd2Editor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGCanvas = { "TGCanvas" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMaterialEditor = { "TGeoMaterialEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMixture = { "TGeoMixture" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMixtureEditor = { "TGeoMixtureEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGListTree = { "TGListTree" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTreeDialog = { "TGeoTreeDialog" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTransientPanel = { "TGeoTransientPanel" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoVolumeDialog = { "TGeoVolumeDialog" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoShapeDialog = { "TGeoShapeDialog" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMediumDialog = { "TGeoMediumDialog" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMaterialDialog = { "TGeoMaterialDialog" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoMatrixDialog = { "TGeoMatrixDialog" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoSphere = { "TGeoSphere" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoSphereEditor = { "TGeoSphereEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoPcon = { "TGeoPcon" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoPconSection = { "TGeoPconSection" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoPconEditor = { "TGeoPconEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoPara = { "TGeoPara" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoParaEditor = { "TGeoParaEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTorus = { "TGeoTorus" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTorusEditor = { "TGeoTorusEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoEltu = { "TGeoEltu" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoEltuEditor = { "TGeoEltuEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoHype = { "TGeoHype" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoHypeEditor = { "TGeoHypeEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoPgonEditor = { "TGeoPgonEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTrap = { "TGeoTrap" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoTrapEditor = { "TGeoTrapEditor" , 99 , -1 };
G__linked_taginfo G__G__GeomBuilderLN_TGeoGtraEditor = { "TGeoGtraEditor" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__GeomBuilder() {
  G__G__GeomBuilderLN_TClass.tagnum = -1 ;
  G__G__GeomBuilderLN_TBuffer.tagnum = -1 ;
  G__G__GeomBuilderLN_TMemberInspector.tagnum = -1 ;
  G__G__GeomBuilderLN_TObject.tagnum = -1 ;
  G__G__GeomBuilderLN_TString.tagnum = -1 ;
  G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GeomBuilderLN_TObjArray.tagnum = -1 ;
  G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GeomBuilderLN_TGWindow.tagnum = -1 ;
  G__G__GeomBuilderLN_TGWidget.tagnum = -1 ;
  G__G__GeomBuilderLN_TGObject.tagnum = -1 ;
  G__G__GeomBuilderLN_TQObject.tagnum = -1 ;
  G__G__GeomBuilderLN_pairlEunsignedsPintcOintgR.tagnum = -1 ;
  G__G__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__GeomBuilderLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GeomBuilderLN_TGFrame.tagnum = -1 ;
  G__G__GeomBuilderLN_TGCompositeFrame.tagnum = -1 ;
  G__G__GeomBuilderLN_TGLayoutHints.tagnum = -1 ;
  G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__GeomBuilderLN_TGTextButton.tagnum = -1 ;
  G__G__GeomBuilderLN_TGMainFrame.tagnum = -1 ;
  G__G__GeomBuilderLN_TGTransientFrame.tagnum = -1 ;
  G__G__GeomBuilderLN_TVirtualPad.tagnum = -1 ;
  G__G__GeomBuilderLN_TCanvas.tagnum = -1 ;
  G__G__GeomBuilderLN_TGLabel.tagnum = -1 ;
  G__G__GeomBuilderLN_TGTab.tagnum = -1 ;
  G__G__GeomBuilderLN_TGedEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGedFrame.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTabManager.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoGedFrame.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoManager.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoVolume.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoShape.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMedium.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMaterial.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMatrix.tagnum = -1 ;
  G__G__GeomBuilderLN_TGTextEntry.tagnum = -1 ;
  G__G__GeomBuilderLN_TGNumberEntry.tagnum = -1 ;
  G__G__GeomBuilderLN_TGComboBox.tagnum = -1 ;
  G__G__GeomBuilderLN_TGPictureButton.tagnum = -1 ;
  G__G__GeomBuilderLN_TGCheckButton.tagnum = -1 ;
  G__G__GeomBuilderLN_TGRadioButton.tagnum = -1 ;
  G__G__GeomBuilderLN_TGShutter.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoVolumeEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoBBox.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoBBoxEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMediumEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoNode.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoNodeEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTranslation.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoRotation.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoCombiTrans.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTranslationEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoRotationEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoCombiTransEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoManagerEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTube.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTubeEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGDoubleVSlider.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTubeSegEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoCtubEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoCone.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoConeEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoConeSegEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTrd1.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTrd1Editor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTrd2.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTrd2Editor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGCanvas.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMaterialEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMixture.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMixtureEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TMap.tagnum = -1 ;
  G__G__GeomBuilderLN_TGListTree.tagnum = -1 ;
  G__G__GeomBuilderLN_TGListTreeItem.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTreeDialog.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTransientPanel.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoVolumeDialog.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoShapeDialog.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMediumDialog.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMaterialDialog.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoMatrixDialog.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoSphere.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoSphereEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoPcon.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoPconSection.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoPconEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoPara.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoParaEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTorus.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTorusEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoEltu.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoEltuEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoHype.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoHypeEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoPgonEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTrap.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoTrapEditor.tagnum = -1 ;
  G__G__GeomBuilderLN_TGeoGtraEditor.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__GeomBuilder() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TString);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGWindow);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGWidget);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_pairlEunsignedsPintcOintgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTextButton);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTransientFrame);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TCanvas);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGLabel);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTab);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGedEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGedFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTabManager),sizeof(TGeoTabManager),-1,62464,"Tab manager for geometry editors",G__setup_memvarTGeoTabManager,G__setup_memfuncTGeoTabManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoGedFrame),sizeof(TGeoGedFrame),-1,61697,"Common base-class for geombuilder editors.",G__setup_memvarTGeoGedFrame,G__setup_memfuncTGeoGedFrame);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoManager);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoVolume);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoShape);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMedium);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMaterial);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMatrix);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTextEntry);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGNumberEntry);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGComboBox);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGPictureButton);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGCheckButton);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGRadioButton);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGShutter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoVolumeEditor),sizeof(TGeoVolumeEditor),-1,62720,"TGeoVolume editor",G__setup_memvarTGeoVolumeEditor,G__setup_memfuncTGeoVolumeEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoBBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoBBoxEditor),sizeof(TGeoBBoxEditor),-1,62720,"TGeoBBox editor",G__setup_memvarTGeoBBoxEditor,G__setup_memfuncTGeoBBoxEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMediumEditor),sizeof(TGeoMediumEditor),-1,62720,"TGeoMedium editor",G__setup_memvarTGeoMediumEditor,G__setup_memfuncTGeoMediumEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoNodeEditor),sizeof(TGeoNodeEditor),-1,62720,"TGeoNode editor",G__setup_memvarTGeoNodeEditor,G__setup_memfuncTGeoNodeEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTranslation);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoRotation);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCombiTrans);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTranslationEditor),sizeof(TGeoTranslationEditor),-1,62720,"TGeoTranslation editor",G__setup_memvarTGeoTranslationEditor,G__setup_memfuncTGeoTranslationEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoRotationEditor),sizeof(TGeoRotationEditor),-1,62720,"TGeoRotation editor",G__setup_memvarTGeoRotationEditor,G__setup_memfuncTGeoRotationEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCombiTransEditor),sizeof(TGeoCombiTransEditor),-1,62720,"TGeoCombiTrans editor",G__setup_memvarTGeoCombiTransEditor,G__setup_memfuncTGeoCombiTransEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoManagerEditor),sizeof(TGeoManagerEditor),-1,62720,"TGeoManager editor",G__setup_memvarTGeoManagerEditor,G__setup_memfuncTGeoManagerEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTube);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTubeEditor),sizeof(TGeoTubeEditor),-1,62720,"TGeoTube editor",G__setup_memvarTGeoTubeEditor,G__setup_memfuncTGeoTubeEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGDoubleVSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTubeSegEditor),sizeof(TGeoTubeSegEditor),-1,62720,"TGeoTubeSeg editor",G__setup_memvarTGeoTubeSegEditor,G__setup_memfuncTGeoTubeSegEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCtubEditor),sizeof(TGeoCtubEditor),-1,62720,"TGeoCtub editor",G__setup_memvarTGeoCtubEditor,G__setup_memfuncTGeoCtubEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCone);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoConeEditor),sizeof(TGeoConeEditor),-1,62720,"TGeoCone editor",G__setup_memvarTGeoConeEditor,G__setup_memfuncTGeoConeEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoConeSegEditor),sizeof(TGeoConeSegEditor),-1,62720,"TGeoConeSeg editor",G__setup_memvarTGeoConeSegEditor,G__setup_memfuncTGeoConeSegEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd1Editor),sizeof(TGeoTrd1Editor),-1,62720,"TGeoTrd1 editor",G__setup_memvarTGeoTrd1Editor,G__setup_memfuncTGeoTrd1Editor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd2Editor),sizeof(TGeoTrd2Editor),-1,62720,"TGeoTrd2 editor",G__setup_memvarTGeoTrd2Editor,G__setup_memfuncTGeoTrd2Editor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGCanvas);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMaterialEditor),sizeof(TGeoMaterialEditor),-1,62720,"TGeoMaterial editor",G__setup_memvarTGeoMaterialEditor,G__setup_memfuncTGeoMaterialEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMixture);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMixtureEditor),sizeof(TGeoMixtureEditor),-1,62720,"TGeoMixture editor",G__setup_memvarTGeoMixtureEditor,G__setup_memfuncTGeoMixtureEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TMap);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGListTree);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGListTreeItem);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTreeDialog),sizeof(TGeoTreeDialog),-1,62468,"List-Tree based dialog",G__setup_memvarTGeoTreeDialog,G__setup_memfuncTGeoTreeDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTransientPanel),sizeof(TGeoTransientPanel),-1,62464,"List-Tree based dialog",G__setup_memvarTGeoTransientPanel,G__setup_memfuncTGeoTransientPanel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoVolumeDialog),sizeof(TGeoVolumeDialog),-1,62464,"List-Tree based volume dialog",G__setup_memvarTGeoVolumeDialog,G__setup_memfuncTGeoVolumeDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoShapeDialog),sizeof(TGeoShapeDialog),-1,62464,"List-Tree based shape dialog",G__setup_memvarTGeoShapeDialog,G__setup_memfuncTGeoShapeDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMediumDialog),sizeof(TGeoMediumDialog),-1,62464,"List-Tree based medium dialog",G__setup_memvarTGeoMediumDialog,G__setup_memfuncTGeoMediumDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMaterialDialog),sizeof(TGeoMaterialDialog),-1,62464,"List-Tree based material dialog",G__setup_memvarTGeoMaterialDialog,G__setup_memfuncTGeoMaterialDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMatrixDialog),sizeof(TGeoMatrixDialog),-1,62464,"List-Tree based matrix dialog",G__setup_memvarTGeoMatrixDialog,G__setup_memfuncTGeoMatrixDialog);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoSphere);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoSphereEditor),sizeof(TGeoSphereEditor),-1,62720,"TGeoSphere editor",G__setup_memvarTGeoSphereEditor,G__setup_memfuncTGeoSphereEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPcon);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPconSection),sizeof(TGeoPconSection),-1,62464,"TGeoPcon section",G__setup_memvarTGeoPconSection,G__setup_memfuncTGeoPconSection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPconEditor),sizeof(TGeoPconEditor),-1,62720,"TGeoPcon editor",G__setup_memvarTGeoPconEditor,G__setup_memfuncTGeoPconEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPara);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoParaEditor),sizeof(TGeoParaEditor),-1,62720,"TGeoPara editor",G__setup_memvarTGeoParaEditor,G__setup_memfuncTGeoParaEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTorus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTorusEditor),sizeof(TGeoTorusEditor),-1,62720,"TGeoTorus editor",G__setup_memvarTGeoTorusEditor,G__setup_memfuncTGeoTorusEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoEltu);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoEltuEditor),sizeof(TGeoEltuEditor),-1,62720,"TGeoEltu editor",G__setup_memvarTGeoEltuEditor,G__setup_memfuncTGeoEltuEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoHype);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoHypeEditor),sizeof(TGeoHypeEditor),-1,62720,"TGeoHype editor",G__setup_memvarTGeoHypeEditor,G__setup_memfuncTGeoHypeEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPgonEditor),sizeof(TGeoPgonEditor),-1,62720,"TGeoPgon editor",G__setup_memvarTGeoPgonEditor,G__setup_memfuncTGeoPgonEditor);
   G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrapEditor),sizeof(TGeoTrapEditor),-1,62720,"TGeoTrap editor",G__setup_memvarTGeoTrapEditor,G__setup_memfuncTGeoTrapEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoGtraEditor),sizeof(TGeoGtraEditor),-1,62720,"TGeoGtra editor",G__setup_memvarTGeoGtraEditor,G__setup_memfuncTGeoGtraEditor);
}
extern "C" void G__cpp_setupG__GeomBuilder(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__GeomBuilder()");
  G__set_cpp_environmentG__GeomBuilder();
  G__cpp_setup_tagtableG__GeomBuilder();

  G__cpp_setup_inheritanceG__GeomBuilder();

  G__cpp_setup_typetableG__GeomBuilder();

  G__cpp_setup_memvarG__GeomBuilder();

  G__cpp_setup_memfuncG__GeomBuilder();
  G__cpp_setup_globalG__GeomBuilder();
  G__cpp_setup_funcG__GeomBuilder();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__GeomBuilder();
  return;
}
class G__cpp_setup_initG__GeomBuilder {
  public:
    G__cpp_setup_initG__GeomBuilder() { G__add_setup_func("G__GeomBuilder",(G__incsetup)(&G__cpp_setupG__GeomBuilder)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__GeomBuilder() { G__remove_setup_func("G__GeomBuilder"); }
};
G__cpp_setup_initG__GeomBuilder G__cpp_setup_initializerG__GeomBuilder;