G__Graf.cxx

Go to the documentation of this file.

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

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

#define R__DICTIONARY_FILENAME graf2ddIgrafdIsrcdIG__Graf
#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__Graf.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void TEllipse_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEllipse(void *p = 0);
   static void *newArray_TEllipse(Long_t size, void *p);
   static void delete_TEllipse(void *p);
   static void deleteArray_TEllipse(void *p);
   static void destruct_TEllipse(void *p);
   static void streamer_TEllipse(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TArc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArc(void *p = 0);
   static void *newArray_TArc(Long_t size, void *p);
   static void delete_TArc(void *p);
   static void deleteArray_TArc(void *p);
   static void destruct_TArc(void *p);

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

namespace ROOT {
   void TLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLine(void *p = 0);
   static void *newArray_TLine(Long_t size, void *p);
   static void delete_TLine(void *p);
   static void deleteArray_TLine(void *p);
   static void destruct_TLine(void *p);
   static void streamer_TLine(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TArrow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrow(void *p = 0);
   static void *newArray_TArrow(Long_t size, void *p);
   static void delete_TArrow(void *p);
   static void deleteArray_TArrow(void *p);
   static void destruct_TArrow(void *p);

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

namespace ROOT {
   void TAttImage_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAttImage(void *p = 0);
   static void *newArray_TAttImage(Long_t size, void *p);
   static void delete_TAttImage(void *p);
   static void deleteArray_TAttImage(void *p);
   static void destruct_TAttImage(void *p);
   static void streamer_TAttImage(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAttImage*)
   {
      ::TAttImage *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAttImage >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TAttImage", ::TAttImage::Class_Version(), "include/TAttImage.h", 108,
                  typeid(::TAttImage), DefineBehavior(ptr, ptr),
                  &::TAttImage::Dictionary, isa_proxy, 0,
                  sizeof(::TAttImage) );
      instance.SetNew(&new_TAttImage);
      instance.SetNewArray(&newArray_TAttImage);
      instance.SetDelete(&delete_TAttImage);
      instance.SetDeleteArray(&deleteArray_TAttImage);
      instance.SetDestructor(&destruct_TAttImage);
      instance.SetStreamerFunc(&streamer_TAttImage);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TAttImage*)
   {
      return GenerateInitInstanceLocal((::TAttImage*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAttImage*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPaletteEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPaletteEditor(void *p);
   static void deleteArray_TPaletteEditor(void *p);
   static void destruct_TPaletteEditor(void *p);
   static void streamer_TPaletteEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TImagePalette_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TImagePalette(void *p = 0);
   static void *newArray_TImagePalette(Long_t size, void *p);
   static void delete_TImagePalette(void *p);
   static void deleteArray_TImagePalette(void *p);
   static void destruct_TImagePalette(void *p);
   static void streamer_TImagePalette(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TImagePalette*)
   {
      ::TImagePalette *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TImagePalette >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TImagePalette", ::TImagePalette::Class_Version(), "include/TAttImage.h", 83,
                  typeid(::TImagePalette), DefineBehavior(ptr, ptr),
                  &::TImagePalette::Dictionary, isa_proxy, 0,
                  sizeof(::TImagePalette) );
      instance.SetNew(&new_TImagePalette);
      instance.SetNewArray(&newArray_TImagePalette);
      instance.SetDelete(&delete_TImagePalette);
      instance.SetDeleteArray(&deleteArray_TImagePalette);
      instance.SetDestructor(&destruct_TImagePalette);
      instance.SetStreamerFunc(&streamer_TImagePalette);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TImagePalette*)
   {
      return GenerateInitInstanceLocal((::TImagePalette*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TImagePalette*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBox(void *p = 0);
   static void *newArray_TBox(Long_t size, void *p);
   static void delete_TBox(void *p);
   static void deleteArray_TBox(void *p);
   static void destruct_TBox(void *p);
   static void streamer_TBox(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TCrown_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCrown(void *p = 0);
   static void *newArray_TCrown(Long_t size, void *p);
   static void delete_TCrown(void *p);
   static void deleteArray_TCrown(void *p);
   static void destruct_TCrown(void *p);

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

namespace ROOT {
   void TPolyLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPolyLine(void *p = 0);
   static void *newArray_TPolyLine(Long_t size, void *p);
   static void delete_TPolyLine(void *p);
   static void deleteArray_TPolyLine(void *p);
   static void destruct_TPolyLine(void *p);
   static void streamer_TPolyLine(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TCurlyLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCurlyLine(void *p = 0);
   static void *newArray_TCurlyLine(Long_t size, void *p);
   static void delete_TCurlyLine(void *p);
   static void deleteArray_TCurlyLine(void *p);
   static void destruct_TCurlyLine(void *p);

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

namespace ROOT {
   void TCurlyArc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCurlyArc(void *p = 0);
   static void *newArray_TCurlyArc(Long_t size, void *p);
   static void delete_TCurlyArc(void *p);
   static void deleteArray_TCurlyArc(void *p);
   static void destruct_TCurlyArc(void *p);

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

namespace ROOT {
   void TCutG_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCutG(void *p = 0);
   static void *newArray_TCutG(Long_t size, void *p);
   static void delete_TCutG(void *p);
   static void deleteArray_TCutG(void *p);
   static void destruct_TCutG(void *p);
   static void streamer_TCutG(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPave_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPave(void *p = 0);
   static void *newArray_TPave(Long_t size, void *p);
   static void delete_TPave(void *p);
   static void deleteArray_TPave(void *p);
   static void destruct_TPave(void *p);
   static void streamer_TPave(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TText(void *p = 0);
   static void *newArray_TText(Long_t size, void *p);
   static void delete_TText(void *p);
   static void deleteArray_TText(void *p);
   static void destruct_TText(void *p);
   static void streamer_TText(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPaveText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPaveText(void *p = 0);
   static void *newArray_TPaveText(Long_t size, void *p);
   static void delete_TPaveText(void *p);
   static void deleteArray_TPaveText(void *p);
   static void destruct_TPaveText(void *p);
   static void streamer_TPaveText(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDiamond_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDiamond(void *p = 0);
   static void *newArray_TDiamond(Long_t size, void *p);
   static void delete_TDiamond(void *p);
   static void deleteArray_TDiamond(void *p);
   static void destruct_TDiamond(void *p);

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

namespace ROOT {
   void TWbox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TWbox(void *p = 0);
   static void *newArray_TWbox(Long_t size, void *p);
   static void delete_TWbox(void *p);
   static void deleteArray_TWbox(void *p);
   static void destruct_TWbox(void *p);

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

namespace ROOT {
   void TFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFrame(void *p = 0);
   static void *newArray_TFrame(Long_t size, void *p);
   static void delete_TFrame(void *p);
   static void deleteArray_TFrame(void *p);
   static void destruct_TFrame(void *p);

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

namespace ROOT {
   void TGaxis_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGaxis(void *p = 0);
   static void *newArray_TGaxis(Long_t size, void *p);
   static void delete_TGaxis(void *p);
   static void deleteArray_TGaxis(void *p);
   static void destruct_TGaxis(void *p);
   static void streamer_TGaxis(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGraphPolargram_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphPolargram(void *p = 0);
   static void *newArray_TGraphPolargram(Long_t size, void *p);
   static void delete_TGraphPolargram(void *p);
   static void deleteArray_TGraphPolargram(void *p);
   static void destruct_TGraphPolargram(void *p);

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

namespace ROOT {
   void TGraphPolar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphPolar(void *p = 0);
   static void *newArray_TGraphPolar(Long_t size, void *p);
   static void delete_TGraphPolar(void *p);
   static void deleteArray_TGraphPolar(void *p);
   static void destruct_TGraphPolar(void *p);

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

namespace ROOT {
   void TGraphQQ_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphQQ(void *p = 0);
   static void *newArray_TGraphQQ(Long_t size, void *p);
   static void delete_TGraphQQ(void *p);
   static void deleteArray_TGraphQQ(void *p);
   static void destruct_TGraphQQ(void *p);

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

namespace ROOT {
   void TImage_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TImage(void *p);
   static void deleteArray_TImage(void *p);
   static void destruct_TImage(void *p);
   static void streamer_TImage(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TImagePlugin_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TImagePlugin(void *p);
   static void deleteArray_TImagePlugin(void *p);
   static void destruct_TImagePlugin(void *p);
   static void streamer_TImagePlugin(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TLatex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLatex(void *p = 0);
   static void *newArray_TLatex(Long_t size, void *p);
   static void delete_TLatex(void *p);
   static void deleteArray_TLatex(void *p);
   static void destruct_TLatex(void *p);

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

namespace ROOT {
   void TLegendEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLegendEntry(void *p = 0);
   static void *newArray_TLegendEntry(Long_t size, void *p);
   static void delete_TLegendEntry(void *p);
   static void deleteArray_TLegendEntry(void *p);
   static void destruct_TLegendEntry(void *p);

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

namespace ROOT {
   void TLegend_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLegend(void *p = 0);
   static void *newArray_TLegend(Long_t size, void *p);
   static void delete_TLegend(void *p);
   static void deleteArray_TLegend(void *p);
   static void destruct_TLegend(void *p);

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

namespace ROOT {
   void TLink_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLink(void *p = 0);
   static void *newArray_TLink(Long_t size, void *p);
   static void delete_TLink(void *p);
   static void deleteArray_TLink(void *p);
   static void destruct_TLink(void *p);

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

namespace ROOT {
   void TMarker_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMarker(void *p = 0);
   static void *newArray_TMarker(Long_t size, void *p);
   static void delete_TMarker(void *p);
   static void deleteArray_TMarker(void *p);
   static void destruct_TMarker(void *p);
   static void streamer_TMarker(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPaveLabel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPaveLabel(void *p = 0);
   static void *newArray_TPaveLabel(Long_t size, void *p);
   static void delete_TPaveLabel(void *p);
   static void deleteArray_TPaveLabel(void *p);
   static void destruct_TPaveLabel(void *p);

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

namespace ROOT {
   void TPaveStats_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPaveStats(void *p = 0);
   static void *newArray_TPaveStats(Long_t size, void *p);
   static void delete_TPaveStats(void *p);
   static void deleteArray_TPaveStats(void *p);
   static void destruct_TPaveStats(void *p);
   static void streamer_TPaveStats(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPavesText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPavesText(void *p = 0);
   static void *newArray_TPavesText(Long_t size, void *p);
   static void delete_TPavesText(void *p);
   static void deleteArray_TPavesText(void *p);
   static void destruct_TPavesText(void *p);

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

namespace ROOT {
   void TPieSlice_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPieSlice(void *p = 0);
   static void *newArray_TPieSlice(Long_t size, void *p);
   static void delete_TPieSlice(void *p);
   static void deleteArray_TPieSlice(void *p);
   static void destruct_TPieSlice(void *p);

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

namespace ROOT {
   void TPie_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPie(void *p = 0);
   static void *newArray_TPie(Long_t size, void *p);
   static void delete_TPie(void *p);
   static void deleteArray_TPie(void *p);
   static void destruct_TPie(void *p);

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

namespace ROOT {
   void TPoints_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPoints(void *p = 0);
   static void *newArray_TPoints(Long_t size, void *p);
   static void delete_TPoints(void *p);
   static void deleteArray_TPoints(void *p);
   static void destruct_TPoints(void *p);

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

namespace ROOT {
   void TTF_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTF(void *p = 0);
   static void *newArray_TTF(Long_t size, void *p);
   static void delete_TTF(void *p);
   static void deleteArray_TTF(void *p);
   static void destruct_TTF(void *p);
   static void streamer_TTF(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTF*)
   {
      ::TTF *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTF >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTF", ::TTF::Class_Version(), "include/TTF.h", 59,
                  typeid(::TTF), DefineBehavior(ptr, ptr),
                  &::TTF::Dictionary, isa_proxy, 0,
                  sizeof(::TTF) );
      instance.SetNew(&new_TTF);
      instance.SetNewArray(&newArray_TTF);
      instance.SetDelete(&delete_TTF);
      instance.SetDeleteArray(&deleteArray_TTF);
      instance.SetDestructor(&destruct_TTF);
      instance.SetStreamerFunc(&streamer_TTF);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTF*)
   {
      return GenerateInitInstanceLocal((::TTF*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTF*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArc(void *p) {
      return  p ? new(p) ::TArc : new ::TArc;
   }
   static void *newArray_TArc(Long_t nElements, void *p) {
      return p ? new(p) ::TArc[nElements] : new ::TArc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArc(void *p) {
      delete ((::TArc*)p);
   }
   static void deleteArray_TArc(void *p) {
      delete [] ((::TArc*)p);
   }
   static void destruct_TArc(void *p) {
      typedef ::TArc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TArc

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrow(void *p) {
      return  p ? new(p) ::TArrow : new ::TArrow;
   }
   static void *newArray_TArrow(Long_t nElements, void *p) {
      return p ? new(p) ::TArrow[nElements] : new ::TArrow[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrow(void *p) {
      delete ((::TArrow*)p);
   }
   static void deleteArray_TArrow(void *p) {
      delete [] ((::TArrow*)p);
   }
   static void destruct_TArrow(void *p) {
      typedef ::TArrow current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TArrow

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      void *ptr_fImageQuality = (void*)&fImageQuality;
      R__b >> *reinterpret_cast<Int_t*>(ptr_fImageQuality);
      R__b >> fImageCompression;
      R__b >> fConstRatio;
      fPalette.Streamer(R__b);
      R__b.CheckByteCount(R__s, R__c, TAttImage::IsA());
   } else {
      R__c = R__b.WriteVersion(TAttImage::IsA(), kTRUE);
      R__b << (Int_t)fImageQuality;
      R__b << fImageCompression;
      R__b << fConstRatio;
      fPalette.Streamer(R__b);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TAttImage::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAttImage.
      TClass *R__cl = ::TAttImage::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImageQuality", &fImageQuality);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImageCompression", &fImageCompression);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConstRatio", &fConstRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPalette", &fPalette);
      R__insp.InspectMember(fPalette, "fPalette.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaletteEditor", &fPaletteEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPaletteEnabled", &fPaletteEnabled);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAttImage(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttImage : new ::TAttImage;
   }
   static void *newArray_TAttImage(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TAttImage[nElements] : new ::TAttImage[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAttImage(void *p) {
      delete ((::TAttImage*)p);
   }
   static void deleteArray_TAttImage(void *p) {
      delete [] ((::TAttImage*)p);
   }
   static void destruct_TAttImage(void *p) {
      typedef ::TAttImage current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAttImage(TBuffer &buf, void *obj) {
      ((::TAttImage*)obj)->::TAttImage::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAttImage

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBox(void *p) {
      return  p ? new(p) ::TBox : new ::TBox;
   }
   static void *newArray_TBox(Long_t nElements, void *p) {
      return p ? new(p) ::TBox[nElements] : new ::TBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBox(void *p) {
      delete ((::TBox*)p);
   }
   static void deleteArray_TBox(void *p) {
      delete [] ((::TBox*)p);
   }
   static void destruct_TBox(void *p) {
      typedef ::TBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBox(TBuffer &buf, void *obj) {
      ((::TBox*)obj)->::TBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBox

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCrown(void *p) {
      return  p ? new(p) ::TCrown : new ::TCrown;
   }
   static void *newArray_TCrown(Long_t nElements, void *p) {
      return p ? new(p) ::TCrown[nElements] : new ::TCrown[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCrown(void *p) {
      delete ((::TCrown*)p);
   }
   static void deleteArray_TCrown(void *p) {
      delete [] ((::TCrown*)p);
   }
   static void destruct_TCrown(void *p) {
      typedef ::TCrown current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCrown

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCurlyArc(void *p) {
      return  p ? new(p) ::TCurlyArc : new ::TCurlyArc;
   }
   static void *newArray_TCurlyArc(Long_t nElements, void *p) {
      return p ? new(p) ::TCurlyArc[nElements] : new ::TCurlyArc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCurlyArc(void *p) {
      delete ((::TCurlyArc*)p);
   }
   static void deleteArray_TCurlyArc(void *p) {
      delete [] ((::TCurlyArc*)p);
   }
   static void destruct_TCurlyArc(void *p) {
      typedef ::TCurlyArc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCurlyArc

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

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

//______________________________________________________________________________
void TCurlyLine::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TCurlyLine.
      TClass *R__cl = ::TCurlyLine::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1", &fX1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1", &fY1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX2", &fX2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY2", &fY2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaveLength", &fWaveLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAmplitude", &fAmplitude);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsteps", &fNsteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsCurly", &fIsCurly);
      TPolyLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCurlyLine(void *p) {
      return  p ? new(p) ::TCurlyLine : new ::TCurlyLine;
   }
   static void *newArray_TCurlyLine(Long_t nElements, void *p) {
      return p ? new(p) ::TCurlyLine[nElements] : new ::TCurlyLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCurlyLine(void *p) {
      delete ((::TCurlyLine*)p);
   }
   static void deleteArray_TCurlyLine(void *p) {
      delete [] ((::TCurlyLine*)p);
   }
   static void destruct_TCurlyLine(void *p) {
      typedef ::TCurlyLine current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCurlyLine

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCutG(void *p) {
      return  p ? new(p) ::TCutG : new ::TCutG;
   }
   static void *newArray_TCutG(Long_t nElements, void *p) {
      return p ? new(p) ::TCutG[nElements] : new ::TCutG[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCutG(void *p) {
      delete ((::TCutG*)p);
   }
   static void deleteArray_TCutG(void *p) {
      delete [] ((::TCutG*)p);
   }
   static void destruct_TCutG(void *p) {
      typedef ::TCutG current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TCutG(TBuffer &buf, void *obj) {
      ((::TCutG*)obj)->::TCutG::Streamer(buf);
   }
} // end of namespace ROOT for class ::TCutG

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDiamond(void *p) {
      return  p ? new(p) ::TDiamond : new ::TDiamond;
   }
   static void *newArray_TDiamond(Long_t nElements, void *p) {
      return p ? new(p) ::TDiamond[nElements] : new ::TDiamond[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDiamond(void *p) {
      delete ((::TDiamond*)p);
   }
   static void deleteArray_TDiamond(void *p) {
      delete [] ((::TDiamond*)p);
   }
   static void destruct_TDiamond(void *p) {
      typedef ::TDiamond current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDiamond

//______________________________________________________________________________
void TEllipse::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEllipse.
      TClass *R__cl = ::TEllipse::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1", &fX1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1", &fY1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR1", &fR1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR2", &fR2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhimin", &fPhimin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhimax", &fPhimax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
      TObject::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEllipse(void *p) {
      return  p ? new(p) ::TEllipse : new ::TEllipse;
   }
   static void *newArray_TEllipse(Long_t nElements, void *p) {
      return p ? new(p) ::TEllipse[nElements] : new ::TEllipse[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEllipse(void *p) {
      delete ((::TEllipse*)p);
   }
   static void deleteArray_TEllipse(void *p) {
      delete [] ((::TEllipse*)p);
   }
   static void destruct_TEllipse(void *p) {
      typedef ::TEllipse current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TEllipse(TBuffer &buf, void *obj) {
      ((::TEllipse*)obj)->::TEllipse::Streamer(buf);
   }
} // end of namespace ROOT for class ::TEllipse

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFrame(void *p) {
      return  p ? new(p) ::TFrame : new ::TFrame;
   }
   static void *newArray_TFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TFrame[nElements] : new ::TFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFrame(void *p) {
      delete ((::TFrame*)p);
   }
   static void deleteArray_TFrame(void *p) {
      delete [] ((::TFrame*)p);
   }
   static void destruct_TFrame(void *p) {
      typedef ::TFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFrame

//______________________________________________________________________________
void TGaxis::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGaxis.
      TClass *R__cl = ::TGaxis::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWmin", &fWmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWmax", &fWmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridLength", &fGridLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTickSize", &fTickSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelOffset", &fLabelOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelSize", &fLabelSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleOffset", &fTitleOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleSize", &fTitleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiv", &fNdiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelColor", &fLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelFont", &fLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChopt", &fChopt);
      R__insp.InspectMember(fChopt, "fChopt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
      R__insp.InspectMember(fTitle, "fTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeFormat", &fTimeFormat);
      R__insp.InspectMember(fTimeFormat, "fTimeFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFunctionName", &fFunctionName);
      R__insp.InspectMember(fFunctionName, "fFunctionName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &fFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxis", &fAxis);
      TLine::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGaxis(void *p) {
      return  p ? new(p) ::TGaxis : new ::TGaxis;
   }
   static void *newArray_TGaxis(Long_t nElements, void *p) {
      return p ? new(p) ::TGaxis[nElements] : new ::TGaxis[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGaxis(void *p) {
      delete ((::TGaxis*)p);
   }
   static void deleteArray_TGaxis(void *p) {
      delete [] ((::TGaxis*)p);
   }
   static void destruct_TGaxis(void *p) {
      typedef ::TGaxis current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGaxis(TBuffer &buf, void *obj) {
      ((::TGaxis*)obj)->::TGaxis::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGaxis

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphPolar(void *p) {
      return  p ? new(p) ::TGraphPolar : new ::TGraphPolar;
   }
   static void *newArray_TGraphPolar(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphPolar[nElements] : new ::TGraphPolar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphPolar(void *p) {
      delete ((::TGraphPolar*)p);
   }
   static void deleteArray_TGraphPolar(void *p) {
      delete [] ((::TGraphPolar*)p);
   }
   static void destruct_TGraphPolar(void *p) {
      typedef ::TGraphPolar current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphPolar

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

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

//______________________________________________________________________________
void TGraphPolargram::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphPolargram.
      TClass *R__cl = ::TGraphPolargram::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadian", &fRadian);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDegree", &fDegree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrad", &fGrad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolarLabelColor", &fPolarLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadialLabelColor", &fRadialLabelColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisAngle", &fAxisAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolarOffset", &fPolarOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolarTextSize", &fPolarTextSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadialOffset", &fRadialOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadialTextSize", &fRadialTextSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRwrmin", &fRwrmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRwrmax", &fRwrmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRwtmin", &fRwtmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRwtmax", &fRwtmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTickpolarSize", &fTickpolarSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolarLabelFont", &fPolarLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadialLabelFont", &fRadialLabelFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutRadial", &fCutRadial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdivRad", &fNdivRad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdivPol", &fNdivPol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPolarLabels", &fPolarLabels);
      TNamed::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphPolargram(void *p) {
      return  p ? new(p) ::TGraphPolargram : new ::TGraphPolargram;
   }
   static void *newArray_TGraphPolargram(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphPolargram[nElements] : new ::TGraphPolargram[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphPolargram(void *p) {
      delete ((::TGraphPolargram*)p);
   }
   static void deleteArray_TGraphPolargram(void *p) {
      delete [] ((::TGraphPolargram*)p);
   }
   static void destruct_TGraphPolargram(void *p) {
      typedef ::TGraphPolargram current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphPolargram

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

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

//______________________________________________________________________________
void TGraphQQ::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphQQ.
      TClass *R__cl = ::TGraphQQ::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNy0", &fNy0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXq1", &fXq1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXq2", &fXq2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYq1", &fYq1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYq2", &fYq2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF", &fF);
      TGraph::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphQQ(void *p) {
      return  p ? new(p) ::TGraphQQ : new ::TGraphQQ;
   }
   static void *newArray_TGraphQQ(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphQQ[nElements] : new ::TGraphQQ[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphQQ(void *p) {
      delete ((::TGraphQQ*)p);
   }
   static void deleteArray_TGraphQQ(void *p) {
      delete [] ((::TGraphQQ*)p);
   }
   static void destruct_TGraphQQ(void *p) {
      typedef ::TGraphQQ current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphQQ

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TNamed::Streamer(R__b);
      TAttImage::Streamer(R__b);
      R__b.CheckByteCount(R__s, R__c, TImage::IsA());
   } else {
      R__c = R__b.WriteVersion(TImage::IsA(), kTRUE);
      TNamed::Streamer(R__b);
      TAttImage::Streamer(R__b);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> fNumPoints;
      delete [] fPoints;
      fPoints = new Double_t[fNumPoints];
      R__b.ReadFastArray(fPoints,fNumPoints);
      delete [] fColorRed;
      fColorRed = new UShort_t[fNumPoints];
      R__b.ReadFastArray(fColorRed,fNumPoints);
      delete [] fColorGreen;
      fColorGreen = new UShort_t[fNumPoints];
      R__b.ReadFastArray(fColorGreen,fNumPoints);
      delete [] fColorBlue;
      fColorBlue = new UShort_t[fNumPoints];
      R__b.ReadFastArray(fColorBlue,fNumPoints);
      delete [] fColorAlpha;
      fColorAlpha = new UShort_t[fNumPoints];
      R__b.ReadFastArray(fColorAlpha,fNumPoints);
      R__b.CheckByteCount(R__s, R__c, TImagePalette::IsA());
   } else {
      R__c = R__b.WriteVersion(TImagePalette::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << fNumPoints;
      R__b.WriteFastArray(fPoints,fNumPoints);
      R__b.WriteFastArray(fColorRed,fNumPoints);
      R__b.WriteFastArray(fColorGreen,fNumPoints);
      R__b.WriteFastArray(fColorBlue,fNumPoints);
      R__b.WriteFastArray(fColorAlpha,fNumPoints);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TImagePalette::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TImagePalette.
      TClass *R__cl = ::TImagePalette::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumPoints", &fNumPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPoints", &fPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorRed", &fColorRed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorGreen", &fColorGreen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorBlue", &fColorBlue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorAlpha", &fColorAlpha);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TImagePalette(void *p) {
      return  p ? new(p) ::TImagePalette : new ::TImagePalette;
   }
   static void *newArray_TImagePalette(Long_t nElements, void *p) {
      return p ? new(p) ::TImagePalette[nElements] : new ::TImagePalette[nElements];
   }
   // Wrapper around operator delete
   static void delete_TImagePalette(void *p) {
      delete ((::TImagePalette*)p);
   }
   static void deleteArray_TImagePalette(void *p) {
      delete [] ((::TImagePalette*)p);
   }
   static void destruct_TImagePalette(void *p) {
      typedef ::TImagePalette current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TImagePalette(TBuffer &buf, void *obj) {
      ((::TImagePalette*)obj)->::TImagePalette::Streamer(buf);
   }
} // end of namespace ROOT for class ::TImagePalette

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

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

//______________________________________________________________________________
void TLatex::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLatex.
      TClass *R__cl = ::TLatex::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFactorSize", &fFactorSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFactorPos", &fFactorPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimitFactorSize", &fLimitFactorSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fError", &fError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShow", &fShow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabSize", &fTabSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOriginSize", &fOriginSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTabMax", &fTabMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fItalic", &fItalic);
      TText::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLatex(void *p) {
      return  p ? new(p) ::TLatex : new ::TLatex;
   }
   static void *newArray_TLatex(Long_t nElements, void *p) {
      return p ? new(p) ::TLatex[nElements] : new ::TLatex[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLatex(void *p) {
      delete ((::TLatex*)p);
   }
   static void deleteArray_TLatex(void *p) {
      delete [] ((::TLatex*)p);
   }
   static void destruct_TLatex(void *p) {
      typedef ::TLatex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLatex

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

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

//______________________________________________________________________________
void TLegend::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLegend.
      TClass *R__cl = ::TLegend::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrimitives", &fPrimitives);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntrySeparation", &fEntrySeparation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMargin", &fMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNColumns", &fNColumns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColumnSeparation", &fColumnSeparation);
      TPave::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLegend(void *p) {
      return  p ? new(p) ::TLegend : new ::TLegend;
   }
   static void *newArray_TLegend(Long_t nElements, void *p) {
      return p ? new(p) ::TLegend[nElements] : new ::TLegend[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLegend(void *p) {
      delete ((::TLegend*)p);
   }
   static void deleteArray_TLegend(void *p) {
      delete [] ((::TLegend*)p);
   }
   static void destruct_TLegend(void *p) {
      typedef ::TLegend current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLegend

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLegendEntry(void *p) {
      return  p ? new(p) ::TLegendEntry : new ::TLegendEntry;
   }
   static void *newArray_TLegendEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TLegendEntry[nElements] : new ::TLegendEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLegendEntry(void *p) {
      delete ((::TLegendEntry*)p);
   }
   static void deleteArray_TLegendEntry(void *p) {
      delete [] ((::TLegendEntry*)p);
   }
   static void destruct_TLegendEntry(void *p) {
      typedef ::TLegendEntry current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLegendEntry

//______________________________________________________________________________
void TLine::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLine.
      TClass *R__cl = ::TLine::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1", &fX1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1", &fY1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX2", &fX2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY2", &fY2);
      TObject::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLine(void *p) {
      return  p ? new(p) ::TLine : new ::TLine;
   }
   static void *newArray_TLine(Long_t nElements, void *p) {
      return p ? new(p) ::TLine[nElements] : new ::TLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLine(void *p) {
      delete ((::TLine*)p);
   }
   static void deleteArray_TLine(void *p) {
      delete [] ((::TLine*)p);
   }
   static void destruct_TLine(void *p) {
      typedef ::TLine current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TLine(TBuffer &buf, void *obj) {
      ((::TLine*)obj)->::TLine::Streamer(buf);
   }
} // end of namespace ROOT for class ::TLine

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLink(void *p) {
      return  p ? new(p) ::TLink : new ::TLink;
   }
   static void *newArray_TLink(Long_t nElements, void *p) {
      return p ? new(p) ::TLink[nElements] : new ::TLink[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLink(void *p) {
      delete ((::TLink*)p);
   }
   static void deleteArray_TLink(void *p) {
      delete [] ((::TLink*)p);
   }
   static void destruct_TLink(void *p) {
      typedef ::TLink current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLink

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMarker(void *p) {
      return  p ? new(p) ::TMarker : new ::TMarker;
   }
   static void *newArray_TMarker(Long_t nElements, void *p) {
      return p ? new(p) ::TMarker[nElements] : new ::TMarker[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMarker(void *p) {
      delete ((::TMarker*)p);
   }
   static void deleteArray_TMarker(void *p) {
      delete [] ((::TMarker*)p);
   }
   static void destruct_TMarker(void *p) {
      typedef ::TMarker current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMarker(TBuffer &buf, void *obj) {
      ((::TMarker*)obj)->::TMarker::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMarker

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

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

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

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

//______________________________________________________________________________
void TPave::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPave.
      TClass *R__cl = ::TPave::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1NDC", &fX1NDC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1NDC", &fY1NDC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX2NDC", &fX2NDC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY2NDC", &fY2NDC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBorderSize", &fBorderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInit", &fInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShadowColor", &fShadowColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCornerRadius", &fCornerRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      TBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPave(void *p) {
      return  p ? new(p) ::TPave : new ::TPave;
   }
   static void *newArray_TPave(Long_t nElements, void *p) {
      return p ? new(p) ::TPave[nElements] : new ::TPave[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPave(void *p) {
      delete ((::TPave*)p);
   }
   static void deleteArray_TPave(void *p) {
      delete [] ((::TPave*)p);
   }
   static void destruct_TPave(void *p) {
      typedef ::TPave current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPave(TBuffer &buf, void *obj) {
      ((::TPave*)obj)->::TPave::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPave

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPaveLabel(void *p) {
      return  p ? new(p) ::TPaveLabel : new ::TPaveLabel;
   }
   static void *newArray_TPaveLabel(Long_t nElements, void *p) {
      return p ? new(p) ::TPaveLabel[nElements] : new ::TPaveLabel[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPaveLabel(void *p) {
      delete ((::TPaveLabel*)p);
   }
   static void deleteArray_TPaveLabel(void *p) {
      delete [] ((::TPaveLabel*)p);
   }
   static void destruct_TPaveLabel(void *p) {
      typedef ::TPaveLabel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPaveLabel

//______________________________________________________________________________
void TPaveStats::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPaveStats.
      TClass *R__cl = ::TPaveStats::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptFit", &fOptFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptStat", &fOptStat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitFormat", &fFitFormat);
      R__insp.InspectMember(fFitFormat, "fFitFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatFormat", &fStatFormat);
      R__insp.InspectMember(fStatFormat, "fStatFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      TPaveText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPaveStats(void *p) {
      return  p ? new(p) ::TPaveStats : new ::TPaveStats;
   }
   static void *newArray_TPaveStats(Long_t nElements, void *p) {
      return p ? new(p) ::TPaveStats[nElements] : new ::TPaveStats[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPaveStats(void *p) {
      delete ((::TPaveStats*)p);
   }
   static void deleteArray_TPaveStats(void *p) {
      delete [] ((::TPaveStats*)p);
   }
   static void destruct_TPaveStats(void *p) {
      typedef ::TPaveStats current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPaveStats(TBuffer &buf, void *obj) {
      ((::TPaveStats*)obj)->::TPaveStats::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPaveStats

//______________________________________________________________________________
void TPaveText::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPaveText.
      TClass *R__cl = ::TPaveText::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel", &fLabel);
      R__insp.InspectMember(fLabel, "fLabel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLongest", &fLongest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMargin", &fMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLines", &fLines);
      TPave::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPaveText(void *p) {
      return  p ? new(p) ::TPaveText : new ::TPaveText;
   }
   static void *newArray_TPaveText(Long_t nElements, void *p) {
      return p ? new(p) ::TPaveText[nElements] : new ::TPaveText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPaveText(void *p) {
      delete ((::TPaveText*)p);
   }
   static void deleteArray_TPaveText(void *p) {
      delete [] ((::TPaveText*)p);
   }
   static void destruct_TPaveText(void *p) {
      typedef ::TPaveText current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPaveText(TBuffer &buf, void *obj) {
      ((::TPaveText*)obj)->::TPaveText::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPaveText

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPavesText(void *p) {
      return  p ? new(p) ::TPavesText : new ::TPavesText;
   }
   static void *newArray_TPavesText(Long_t nElements, void *p) {
      return p ? new(p) ::TPavesText[nElements] : new ::TPavesText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPavesText(void *p) {
      delete ((::TPavesText*)p);
   }
   static void deleteArray_TPavesText(void *p) {
      delete [] ((::TPavesText*)p);
   }
   static void destruct_TPavesText(void *p) {
      typedef ::TPavesText current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPavesText

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

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

//______________________________________________________________________________
void TPie::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPie.
      TClass *R__cl = ::TPie::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSum", &fSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlices", &fSlices);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegend", &fLegend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadius", &fRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngularOffset", &fAngularOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelsOffset", &fLabelsOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelFormat", &fLabelFormat);
      R__insp.InspectMember(fLabelFormat, "fLabelFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValueFormat", &fValueFormat);
      R__insp.InspectMember(fValueFormat, "fValueFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFractionFormat", &fFractionFormat);
      R__insp.InspectMember(fFractionFormat, "fFractionFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPercentFormat", &fPercentFormat);
      R__insp.InspectMember(fPercentFormat, "fPercentFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNvals", &fNvals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPieSlices", &fPieSlices);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIs3D", &fIs3D);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle3D", &fAngle3D);
      TNamed::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPie(void *p) {
      return  p ? new(p) ::TPie : new ::TPie;
   }
   static void *newArray_TPie(Long_t nElements, void *p) {
      return p ? new(p) ::TPie[nElements] : new ::TPie[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPie(void *p) {
      delete ((::TPie*)p);
   }
   static void deleteArray_TPie(void *p) {
      delete [] ((::TPie*)p);
   }
   static void destruct_TPie(void *p) {
      typedef ::TPie current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPie

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

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

//______________________________________________________________________________
void TPieSlice::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPieSlice.
      TClass *R__cl = ::TPieSlice::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsActive", &fIsActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPie", &fPie);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadiusOffset", &fRadiusOffset);
      TNamed::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPieSlice(void *p) {
      return  p ? new(p) ::TPieSlice : new ::TPieSlice;
   }
   static void *newArray_TPieSlice(Long_t nElements, void *p) {
      return p ? new(p) ::TPieSlice[nElements] : new ::TPieSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPieSlice(void *p) {
      delete ((::TPieSlice*)p);
   }
   static void deleteArray_TPieSlice(void *p) {
      delete [] ((::TPieSlice*)p);
   }
   static void destruct_TPieSlice(void *p) {
      typedef ::TPieSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPieSlice

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPoints(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPoints : new ::TPoints;
   }
   static void *newArray_TPoints(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPoints[nElements] : new ::TPoints[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPoints(void *p) {
      delete ((::TPoints*)p);
   }
   static void deleteArray_TPoints(void *p) {
      delete [] ((::TPoints*)p);
   }
   static void destruct_TPoints(void *p) {
      typedef ::TPoints current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPoints

//______________________________________________________________________________
void TPolyLine::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPolyLine.
      TClass *R__cl = ::TPolyLine::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPoint", &fLastPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      TObject::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPolyLine(void *p) {
      return  p ? new(p) ::TPolyLine : new ::TPolyLine;
   }
   static void *newArray_TPolyLine(Long_t nElements, void *p) {
      return p ? new(p) ::TPolyLine[nElements] : new ::TPolyLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPolyLine(void *p) {
      delete ((::TPolyLine*)p);
   }
   static void deleteArray_TPolyLine(void *p) {
      delete [] ((::TPolyLine*)p);
   }
   static void destruct_TPolyLine(void *p) {
      typedef ::TPolyLine current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPolyLine(TBuffer &buf, void *obj) {
      ((::TPolyLine*)obj)->::TPolyLine::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPolyLine

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TText(void *p) {
      return  p ? new(p) ::TText : new ::TText;
   }
   static void *newArray_TText(Long_t nElements, void *p) {
      return p ? new(p) ::TText[nElements] : new ::TText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TText(void *p) {
      delete ((::TText*)p);
   }
   static void deleteArray_TText(void *p) {
      delete [] ((::TText*)p);
   }
   static void destruct_TText(void *p) {
      typedef ::TText current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TText(TBuffer &buf, void *obj) {
      ((::TText*)obj)->::TText::Streamer(buf);
   }
} // end of namespace ROOT for class ::TText

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTF(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTF : new ::TTF;
   }
   static void *newArray_TTF(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTF[nElements] : new ::TTF[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTF(void *p) {
      delete ((::TTF*)p);
   }
   static void deleteArray_TTF(void *p) {
      delete [] ((::TTF*)p);
   }
   static void destruct_TTF(void *p) {
      typedef ::TTF current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTF(TBuffer &buf, void *obj) {
      ((::TTF*)obj)->::TTF::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTF

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TWbox(void *p) {
      return  p ? new(p) ::TWbox : new ::TWbox;
   }
   static void *newArray_TWbox(Long_t nElements, void *p) {
      return p ? new(p) ::TWbox[nElements] : new ::TWbox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TWbox(void *p) {
      delete ((::TWbox*)p);
   }
   static void deleteArray_TWbox(void *p) {
      delete [] ((::TWbox*)p);
   }
   static void destruct_TWbox(void *p) {
      typedef ::TWbox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TWbox

/********************************************************
* graf2d/graf/src/G__Graf.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__Graf();

extern "C" void G__set_cpp_environmentG__Graf() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TArc.h");
  G__add_compiledheader("TArrow.h");
  G__add_compiledheader("TAttImage.h");
  G__add_compiledheader("TBox.h");
  G__add_compiledheader("TCrown.h");
  G__add_compiledheader("TCurlyArc.h");
  G__add_compiledheader("TCurlyLine.h");
  G__add_compiledheader("TCutG.h");
  G__add_compiledheader("TDiamond.h");
  G__add_compiledheader("TEllipse.h");
  G__add_compiledheader("TFrame.h");
  G__add_compiledheader("TGaxis.h");
  G__add_compiledheader("TGraphPolargram.h");
  G__add_compiledheader("TGraphPolar.h");
  G__add_compiledheader("TGraphQQ.h");
  G__add_compiledheader("TImage.h");
  G__add_compiledheader("TImagePlugin.h");
  G__add_compiledheader("TLatex.h");
  G__add_compiledheader("TLegendEntry.h");
  G__add_compiledheader("TLegend.h");
  G__add_compiledheader("TLine.h");
  G__add_compiledheader("TLink.h");
  G__add_compiledheader("TMarker.h");
  G__add_compiledheader("TPave.h");
  G__add_compiledheader("TPaveLabel.h");
  G__add_compiledheader("TPaveStats.h");
  G__add_compiledheader("TPavesText.h");
  G__add_compiledheader("TPaveText.h");
  G__add_compiledheader("TPie.h");
  G__add_compiledheader("TPieSlice.h");
  G__add_compiledheader("TPoints.h");
  G__add_compiledheader("TPolyLine.h");
  G__add_compiledheader("TText.h");
  G__add_compiledheader("TTF.h");
  G__add_compiledheader("TWbox.h");
  G__cpp_reset_tagtableG__Graf();
}
#include <new>
extern "C" int G__cpp_dllrevG__Graf() { return(30051515); }

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

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

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

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

static int G__G__Graf_102_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TEllipse*) G__getstructoffset())->DrawEllipse(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Option_t*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TEllipse*) G__getstructoffset())->DrawEllipse(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Graf_102_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TEllipse*) G__getstructoffset())->PaintEllipse(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Option_t*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TEllipse*) G__getstructoffset())->PaintEllipse(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_102_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEllipse*) G__getstructoffset())->SetPhimin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEllipse*) G__getstructoffset())->SetPhimin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_102_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEllipse*) G__getstructoffset())->SetPhimax((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEllipse*) G__getstructoffset())->SetPhimax();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Graf_102_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEllipse*) G__getstructoffset())->SetTheta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEllipse*) G__getstructoffset())->SetTheta();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Graf_104_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TArc*) G__getstructoffset())->DrawArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TArc*) G__getstructoffset())->DrawArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TArc*) G__getstructoffset())->DrawArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TArc*) G__getstructoffset())->DrawArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Graf_116_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLine*) G__getstructoffset())->DrawLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_116_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLine*) G__getstructoffset())->DrawLineNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Graf_116_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLine*) G__getstructoffset())->PaintLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_116_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLine*) G__getstructoffset())->PaintLineNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Graf_118_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TArrow*) G__getstructoffset())->DrawArrow((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TArrow*) G__getstructoffset())->DrawArrow((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TArrow*) G__getstructoffset())->DrawArrow((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TArrow*) G__getstructoffset())->GetAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TArrow*) G__getstructoffset())->GetArrowSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TArrow*) G__getstructoffset())->PaintArrow((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TArrow*) G__getstructoffset())->PaintArrow((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TArrow*) G__getstructoffset())->PaintArrow((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TArrow*) G__getstructoffset())->SetAngle((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TArrow*) G__getstructoffset())->SetAngle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TArrow*) G__getstructoffset())->SetArrowSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TArrow*) G__getstructoffset())->SetArrowSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_118_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TArrow::SetDefaultAngle((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TArrow::SetDefaultArrowSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_118_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TArrow::GetDefaultAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_118_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TArrow::GetDefaultArrowSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

static int G__G__Graf_119_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TImagePalette& obj = ((const TAttImage*) G__getstructoffset())->GetPalette();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_119_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TAttImage*) G__getstructoffset())->SaveImageAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (TAttImage::EImageQuality) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TAttImage*) G__getstructoffset())->SaveImageAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (TAttImage::EImageQuality) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TAttImage*) G__getstructoffset())->SaveImageAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (TAttImage::EImageQuality) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TAttImage*) G__getstructoffset())->SaveImageAttributes(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Graf_119_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttImage*) G__getstructoffset())->SetImageQuality((TAttImage::EImageQuality) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_119_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAttImage*) G__getstructoffset())->SetPalette((TImagePalette*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Graf_121_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TImagePalette*) G__getstructoffset())->GetRootColors());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Graf_123_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBox*) G__getstructoffset())->DrawBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Graf_123_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TBox*) G__getstructoffset())->IsInside((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_123_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TBox*) G__getstructoffset())->PaintBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TBox*) G__getstructoffset())->PaintBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Graf_125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TCrown*) G__getstructoffset())->DrawCrown(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TCrown*) G__getstructoffset())->DrawCrown((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TCrown*) G__getstructoffset())->DrawCrown((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TCrown*) G__getstructoffset())->DrawCrown((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

static int G__G__Graf_127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TPolyLine*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TPolyLine*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Graf_127_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TPolyLine*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TPolyLine*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Graf_129_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCurlyLine::SetDefaultWaveLength((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCurlyLine::SetDefaultAmplitude((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_129_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TCurlyLine::GetDefaultWaveLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_129_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TCurlyLine::GetDefaultAmplitude());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

static int G__G__Graf_131_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCurlyArc::SetDefaultWaveLength((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_131_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCurlyArc::SetDefaultAmplitude((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_131_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TCurlyArc::GetDefaultWaveLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_131_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TCurlyArc::GetDefaultAmplitude());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

static int G__G__Graf_146_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TCutG*) G__getstructoffset())->IntegralHist((TH2*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TCutG*) G__getstructoffset())->IntegralHist((TH2*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Graf_147_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TPave*) G__getstructoffset())->DrawPave((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TPave*) G__getstructoffset())->DrawPave((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TPave*) G__getstructoffset())->DrawPave((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Graf_147_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TPave*) G__getstructoffset())->PaintPave((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TPave*) G__getstructoffset())->PaintPave((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TPave*) G__getstructoffset())->PaintPave((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_147_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TPave*) G__getstructoffset())->PaintPaveArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TPave*) G__getstructoffset())->PaintPaveArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TPave*) G__getstructoffset())->PaintPaveArc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_147_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPave*) G__getstructoffset())->SetCornerRadius((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPave*) G__getstructoffset())->SetCornerRadius();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Graf_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TText*) G__getstructoffset())->DrawText((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_150_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TText*) G__getstructoffset())->DrawTextNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_150_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TText*) G__getstructoffset())->GetControlBox((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Graf_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TText*) G__getstructoffset())->GetTextAscentDescent(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TText*) G__getstructoffset())->GetTextExtent(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TText*) G__getstructoffset())->GetTextAdvance(*(UInt_t*) G__UIntref(&libp->para[0]), (const char*) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TText*) G__getstructoffset())->GetTextAdvance(*(UInt_t*) G__UIntref(&libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Graf_152_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddBox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_152_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddLine((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddLine((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddLine());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_152_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TPaveText*) G__getstructoffset())->AddText((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Graf_152_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TPaveText*) G__getstructoffset())->GetMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPaveText*) G__getstructoffset())->GetObject(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Graf_152_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveText*) G__getstructoffset())->SaveLines(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_152_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveText*) G__getstructoffset())->SetAllWith((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_152_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPaveText*) G__getstructoffset())->SetMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPaveText*) G__getstructoffset())->SetMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Graf_157_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TWbox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5])
, (Short_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5])
, (Short_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TWbox));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Graf_157_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TWbox*) G__getstructoffset())->DrawWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5])
, (Short_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TWbox*) G__getstructoffset())->DrawWbox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TWbox*) G__getstructoffset())->DrawWbox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TWbox*) G__getstructoffset())->DrawWbox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Graf_157_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TWbox*) G__getstructoffset())->PaintFrame(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5])
, (Short_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_157_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TWbox*) G__getstructoffset())->PaintWbox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5])
, (Short_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TWbox*) G__getstructoffset())->PaintWbox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]), (Short_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TWbox*) G__getstructoffset())->PaintWbox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Color_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TWbox*) G__getstructoffset())->PaintWbox((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Graf_159_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGaxis*) G__getstructoffset())->AdjustBinSize(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Graf_159_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      ((TGaxis*) G__getstructoffset())->DrawAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7])
, (Double_t) G__double(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TGaxis*) G__getstructoffset())->DrawAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TGaxis*) G__getstructoffset())->DrawAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TGaxis*) G__getstructoffset())->DrawAxis((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGaxis*) G__getstructoffset())->GetGridLength());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Graf_159_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGaxis*) G__getstructoffset())->GetLabelOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGaxis*) G__getstructoffset())->GetLabelSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGaxis*) G__getstructoffset())->GetTitleOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGaxis*) G__getstructoffset())->GetTitleSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Graf_159_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGaxis*) G__getstructoffset())->GetTickSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGaxis*) G__getstructoffset())->ImportAxisAttributes((TAxis*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGaxis*) G__getstructoffset())->LabelsLimits((const char*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      ((TGaxis*) G__getstructoffset())->PaintAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6]), (Option_t*) G__int(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Bool_t) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGaxis*) G__getstructoffset())->PaintAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6]), (Option_t*) G__int(libp->para[7])
, (Double_t) G__double(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TGaxis*) G__getstructoffset())->PaintAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6]), (Option_t*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TGaxis*) G__getstructoffset())->PaintAxis(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_159_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGaxis*) G__getstructoffset())->Rotate(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), *(Double_t*) G__Doubleref(&libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Graf_159_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGaxis*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGaxis*) G__getstructoffset())->SetTitleOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Graf_159_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGaxis::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGaxis G__TTGaxis;
static int G__G__Graf_159_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGaxis*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGaxis*) (soff+(sizeof(TGaxis)*i)))->~G__TTGaxis();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGaxis*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGaxis*) (soff))->~G__TTGaxis();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphPolargram */
static int G__G__Graf_160_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphPolargram* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphPolargram(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGraphPolargram(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphPolargram* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolargram((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGraphPolargram((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGraphPolargram[n];
       } else {
         p = new((void*) gvp) TGraphPolargram[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGraphPolargram;
       } else {
         p = new((void*) gvp) TGraphPolargram;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((TGraphPolargram*) G__getstructoffset())->GetPolarColorLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((TGraphPolargram*) G__getstructoffset())->GetRadialColorLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetPolarLabelSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetPolarOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetRadialLabelSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetRadialOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetRMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetRMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetTickpolarSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetTMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphPolargram*) G__getstructoffset())->GetTMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((TGraphPolargram*) G__getstructoffset())->GetPolarLabelFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((TGraphPolargram*) G__getstructoffset())->GetRadialLabelFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraphPolargram*) G__getstructoffset())->GetNdivPolar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraphPolargram*) G__getstructoffset())->GetNdivRadial());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGraphPolargram*) G__getstructoffset())->IsDegree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGraphPolargram*) G__getstructoffset())->IsRadian());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGraphPolargram*) G__getstructoffset())->IsGrad());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->ChangeRangePolar((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->PaintCircle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetAxisAngle((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetAxisAngle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetNdivPolar((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetNdivPolar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetNdivRadial((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetNdivRadial();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabel((Int_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabelSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabelSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabelColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabelColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabelFont((Font_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarLabelFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetPolarOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialLabelSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialLabelSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialLabelColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialLabelColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialLabelFont((Font_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetRadialLabelFont();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetRangePolar((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetRangeRadial((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolargram*) G__getstructoffset())->SetTickpolarSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolargram*) G__getstructoffset())->SetTickpolarSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetToDegree();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetToGrad();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetToRadian();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->SetTwoPi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphPolargram::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphPolargram::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphPolargram::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphPolargram::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolargram*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphPolargram::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphPolargram::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphPolargram::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_160_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphPolargram::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_160_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGraphPolargram* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGraphPolargram(*(TGraphPolargram*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphPolargram G__TTGraphPolargram;
static int G__G__Graf_160_0_66(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[] (TGraphPolargram*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphPolargram*) (soff+(sizeof(TGraphPolargram)*i)))->~G__TTGraphPolargram();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphPolargram*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphPolargram*) (soff))->~G__TTGraphPolargram();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_160_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphPolargram* dest = (TGraphPolargram*) G__getstructoffset();
   *dest = *(TGraphPolargram*) libp->para[0].ref;
   const TGraphPolargram& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphPolar */
static int G__G__Graf_163_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphPolar* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar[n];
     } else {
       p = new((void*) gvp) TGraphPolar[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar;
     } else {
       p = new((void*) gvp) TGraphPolar;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphPolar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphPolar(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphPolar(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphPolar(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGraphPolar((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphPolar((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGraphPolar((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGraphPolar*) G__getstructoffset())->GetPolargram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGraphPolar*) G__getstructoffset())->GetOptionAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolar*) G__getstructoffset())->SetMaxRadial((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolar*) G__getstructoffset())->SetMaxRadial();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolar*) G__getstructoffset())->SetMinRadial((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolar*) G__getstructoffset())->SetMinRadial();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolar*) G__getstructoffset())->SetMaxPolar((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolar*) G__getstructoffset())->SetMaxPolar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphPolar*) G__getstructoffset())->SetMinPolar((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphPolar*) G__getstructoffset())->SetMinPolar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolar*) G__getstructoffset())->SetOptionAxis((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolar*) G__getstructoffset())->SetPolargram((TGraphPolargram*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGraphPolar*) G__getstructoffset())->GetXpol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGraphPolar*) G__getstructoffset())->GetYpol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphPolar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphPolar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphPolar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphPolar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphPolar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphPolar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphPolar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphPolar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_163_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphPolar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_163_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGraphPolar* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGraphPolar(*(TGraphPolar*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphPolar G__TTGraphPolar;
static int G__G__Graf_163_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[] (TGraphPolar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphPolar*) (soff+(sizeof(TGraphPolar)*i)))->~G__TTGraphPolar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphPolar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphPolar*) (soff))->~G__TTGraphPolar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_163_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphPolar* dest = (TGraphPolar*) G__getstructoffset();
   *dest = *(TGraphPolar*) libp->para[0].ref;
   const TGraphPolar& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphQQ */
static int G__G__Graf_164_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphQQ* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphQQ[n];
     } else {
       p = new((void*) gvp) TGraphQQ[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphQQ;
     } else {
       p = new((void*) gvp) TGraphQQ;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphQQ* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphQQ((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGraphQQ((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphQQ* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphQQ(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGraphQQ(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphQQ* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphQQ(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGraphQQ(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_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__GrafLN_TGraphQQ));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphQQ*) G__getstructoffset())->SetFunction((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphQQ*) G__getstructoffset())->GetXq1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphQQ*) G__getstructoffset())->GetXq2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphQQ*) G__getstructoffset())->GetYq1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphQQ*) G__getstructoffset())->GetYq2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraphQQ*) G__getstructoffset())->GetF());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphQQ::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphQQ::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphQQ::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphQQ::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphQQ*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphQQ::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphQQ::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphQQ::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_164_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphQQ::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_164_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGraphQQ* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGraphQQ(*(TGraphQQ*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphQQ G__TTGraphQQ;
static int G__G__Graf_164_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[] (TGraphQQ*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphQQ*) (soff+(sizeof(TGraphQQ)*i)))->~G__TTGraphQQ();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphQQ*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphQQ*) (soff))->~G__TTGraphQQ();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_164_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphQQ* dest = (TGraphQQ*) G__getstructoffset();
   *dest = *(TGraphQQ*) libp->para[0].ref;
   const TGraphQQ& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TImage */
static int G__G__Graf_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TImage* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TImage(*(TImage*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TImage(*(TImage*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TImage));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TImage& obj = ((TImage*) G__getstructoffset())->operator=(*(TImage*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TImage* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TImage((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TImage((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TImage));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TImage*) G__getstructoffset())->ReadImage((const char*) G__int(libp->para[0]), (TImage::EImageFileTypes) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->ReadImage((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TImage*) G__getstructoffset())->WriteImage((const char*) G__int(libp->para[0]), (TImage::EImageFileTypes) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->WriteImage((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TImage*) G__getstructoffset())->SetImage((Double_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TImagePalette*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->SetImage((Double_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TImage*) G__getstructoffset())->SetImage(*(TArrayD*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (TImagePalette*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->SetImage(*(TArrayD*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TImage*) G__getstructoffset())->SetImage(*(TVectorD*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (TImagePalette*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->SetImage(*(TVectorD*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TImage*) G__getstructoffset())->SetImage((Pixmap_t) G__int(libp->para[0]), (Pixmap_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->SetImage((Pixmap_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->FromPad((TVirtualPad*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->FromPad((TVirtualPad*) 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]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->FromPad((TVirtualPad*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->FromPad((TVirtualPad*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->FromPad((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->UnZoom();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->Zoom((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TImage*) G__getstructoffset())->Flip((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Flip();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TImage*) G__getstructoffset())->Gray((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Gray();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TImage*) G__getstructoffset())->IsGray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TImage*) G__getstructoffset())->Mirror((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Mirror();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->Scale((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->Slice((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->Tile((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TImage*) G__getstructoffset())->Crop((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->Crop((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->Crop((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Crop((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Crop();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->Pad((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->Pad((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->Pad((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->Pad((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Pad((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Pad();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TImage*) G__getstructoffset())->Blur((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Blur((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Blur();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 68, (long) ((TImage*) G__getstructoffset())->Vectorize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 68, (long) ((TImage*) G__getstructoffset())->Vectorize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 68, (long) ((TImage*) G__getstructoffset())->Vectorize((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 68, (long) ((TImage*) G__getstructoffset())->Vectorize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      ((TImage*) G__getstructoffset())->HSV(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TImage*) G__getstructoffset())->HSV(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->HSV(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->HSV((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->HSV((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->HSV((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->HSV((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->HSV((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->HSV((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->HSV();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TImage*) G__getstructoffset())->Gradient(
(UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->Gradient((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->Gradient((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->Gradient((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->Gradient((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->Gradient((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Gradient((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Gradient();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TImage*) G__getstructoffset())->Merge((TImage*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->Merge((TImage*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->Merge((TImage*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Merge((TImage*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TImage*) G__getstructoffset())->Append((TImage*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->Append((TImage*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Append((TImage*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TImage*) G__getstructoffset())->Bevel(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (UShort_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->Bevel(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (UShort_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->Bevel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->Bevel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->Bevel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->Bevel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->Bevel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->Bevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->Bevel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TImage*) G__getstructoffset())->BeginPaint((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->BeginPaint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->EndPaint();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TImage*) G__getstructoffset())->DrawLine((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawLine((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawLine((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TImage*) G__getstructoffset())->DrawDashLine(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->DrawDashLine(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->DrawDashLine((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TImage*) G__getstructoffset())->DrawBox(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->DrawBox((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawBox((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawBox((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TImage*) G__getstructoffset())->DrawRectangle((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawRectangle((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawRectangle((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->FillRectangle((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->FillRectangle((const char*) 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]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->FillRectangle((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->FillRectangle((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->FillRectangle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->FillRectangle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->DrawPolyLine((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (TImage::ECoordMode) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawPolyLine((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->DrawPolyLine((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->DrawPolyLine((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TImage*) G__getstructoffset())->PutPixel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->PutPixel((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TImage*) G__getstructoffset())->PolyPoint((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TImage::ECoordMode) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->PolyPoint((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->PolyPoint((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TImage*) G__getstructoffset())->DrawSegments((UInt_t) G__int(libp->para[0]), (Segment_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->DrawSegments((UInt_t) G__int(libp->para[0]), (Segment_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->DrawSegments((UInt_t) G__int(libp->para[0]), (Segment_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      ((TImage*) G__getstructoffset())->DrawText(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (TImage::EText3DType) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (Float_t) G__double(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TImage*) G__getstructoffset())->DrawText(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (TImage::EText3DType) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->DrawText(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (TImage::EText3DType) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->DrawText((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->DrawText();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TImage*) G__getstructoffset())->DrawText((TText*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->DrawText((TText*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->DrawText((TText*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TImage*) G__getstructoffset())->FillPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->FillPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->FillPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->FillPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->FillPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->FillPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (TImage*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->CropPolygon((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TImage*) G__getstructoffset())->DrawFillArea((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawFillArea((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawFillArea((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->DrawFillArea((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->DrawFillArea((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->DrawFillArea((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (TImage*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TImage*) G__getstructoffset())->FillSpans(
(UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->FillSpans((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->FillSpans((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->FillSpans((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->FillSpans((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->FillSpans((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]), (TImage*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->CropSpans((UInt_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      ((TImage*) G__getstructoffset())->CopyArea(
(TImage*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (TImage::EColorChan) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TImage*) G__getstructoffset())->CopyArea(
(TImage*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->CopyArea(
(TImage*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->CopyArea((TImage*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->CopyArea((TImage*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->DrawCellArray(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (UInt_t*) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->FloodFill((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->FloodFill((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TImage*) G__getstructoffset())->DrawCubeBezier(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->DrawCubeBezier(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->DrawCubeBezier((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TImage*) G__getstructoffset())->DrawStraightEllips((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawStraightEllips((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawStraightEllips((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->DrawCircle((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->DrawCircle((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->DrawCircle((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TImage*) G__getstructoffset())->DrawEllips(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->DrawEllips((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawEllips((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TImage*) G__getstructoffset())->DrawEllips2(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->DrawEllips2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->DrawEllips2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TImage*) G__getstructoffset())->SetEditable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TImage*) G__getstructoffset())->SetEditable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TImage*) G__getstructoffset())->IsEditable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TImage*) G__getstructoffset())->GetWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TImage*) G__getstructoffset())->GetHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TImage*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TImage*) G__getstructoffset())->GetScaledImage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetPixels((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetPixels((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetPixels((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetPixels((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetPixels());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetArray((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (TImagePalette*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetArray((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetArray((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TImage*) G__getstructoffset())->GetArray());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TImage*) G__getstructoffset())->GetPixmap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TImage*) G__getstructoffset())->GetMask());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((TImage*) G__getstructoffset())->GetArgbArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((TImage*) G__getstructoffset())->GetRgbaArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TImage*) G__getstructoffset())->GetVecArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((TImage*) G__getstructoffset())->GetScanline((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TImage*) G__getstructoffset())->GetImageBuffer((char**) G__int(libp->para[0]), (int*) G__int(libp->para[1])
, (TImage::EImageFileTypes) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->GetImageBuffer((char**) G__int(libp->para[0]), (int*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TImage*) G__getstructoffset())->SetImageBuffer((char**) G__int(libp->para[0]), (TImage::EImageFileTypes) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TImage*) G__getstructoffset())->SetImageBuffer((char**) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TImage*) G__getstructoffset())->PaintImage(
(Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TImage*) G__getstructoffset())->PaintImage(
(Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TImage*) G__getstructoffset())->PaintImage((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TImage*) G__getstructoffset())->PaintImage((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->PaintImage((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->PaintImage((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TImage*) G__getstructoffset())->FromWindow((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TImage*) G__getstructoffset())->FromWindow((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TImage*) G__getstructoffset())->FromWindow((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TImage*) G__getstructoffset())->FromWindow((Drawable_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TImage*) G__getstructoffset())->FromWindow((Drawable_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->FromGLBuffer((UChar_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TImage::GetImageFileTypeFromFilename((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TImage::Create());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0]), (TImage::EImageFileTypes) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TImage::Open((char**) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (TImagePalette*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0]), *(TArrayD*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (TImagePalette*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0]), *(TArrayD*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0]), *(TVectorD*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (TImagePalette*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TImage::Open((const char*) G__int(libp->para[0]), *(TVectorD*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TImage& obj = ((TImage*) G__getstructoffset())->operator+=(*(TImage*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TImage& obj = ((TImage*) G__getstructoffset())->operator/=(*(TImage*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TImage::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TImage::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TImage::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TImage::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImage*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TImage::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TImage::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TImage::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_186_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TImage::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TImage G__TTImage;
static int G__G__Graf_186_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TImage*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TImage*) (soff+(sizeof(TImage)*i)))->~G__TTImage();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TImage*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TImage*) (soff))->~G__TTImage();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TImagePlugin */
static int G__G__Graf_193_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TImagePlugin*) G__getstructoffset())->ReadFile((const char*) G__int(libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TImagePlugin*) G__getstructoffset())->WriteFile((const char*) G__int(libp->para[0]), (unsigned char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TImagePlugin::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TImagePlugin::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TImagePlugin::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TImagePlugin::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TImagePlugin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TImagePlugin::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TImagePlugin::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TImagePlugin::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_193_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TImagePlugin::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TImagePlugin G__TTImagePlugin;
static int G__G__Graf_193_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TImagePlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TImagePlugin*) (soff+(sizeof(TImagePlugin)*i)))->~G__TTImagePlugin();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TImagePlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TImagePlugin*) (soff))->~G__TTImagePlugin();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_193_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TImagePlugin* dest = (TImagePlugin*) G__getstructoffset();
   *dest = *(TImagePlugin*) libp->para[0].ref;
   const TImagePlugin& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLatex */
static int G__G__Graf_197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLatex* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLatex[n];
     } else {
       p = new((void*) gvp) TLatex[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLatex;
     } else {
       p = new((void*) gvp) TLatex;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLatex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLatex* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLatex(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLatex(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLatex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLatex* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLatex(*(TLatex*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TLatex(*(TLatex*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLatex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLatex*) G__getstructoffset())->DrawLatex((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TLatex*) G__getstructoffset())->GetHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TLatex*) G__getstructoffset())->GetXsize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TLatex*) G__getstructoffset())->GetYsize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLatex*) G__getstructoffset())->PaintLatex((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLatex*) G__getstructoffset())->SetIndiceSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLatex*) G__getstructoffset())->SetLimitIndiceSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLatex::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLatex::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLatex::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLatex::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLatex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLatex::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLatex::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLatex::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_197_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLatex::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLatex G__TTLatex;
static int G__G__Graf_197_0_37(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[] (TLatex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLatex*) (soff+(sizeof(TLatex)*i)))->~G__TTLatex();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLatex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLatex*) (soff))->~G__TTLatex();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLegendEntry */
static int G__G__Graf_199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLegendEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegendEntry[n];
     } else {
       p = new((void*) gvp) TLegendEntry[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegendEntry;
     } else {
       p = new((void*) gvp) TLegendEntry;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLegendEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegendEntry(
(TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TLegendEntry(
(TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegendEntry((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TLegendEntry((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegendEntry((TObject*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TLegendEntry((TObject*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLegendEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLegendEntry(*(TLegendEntry*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TLegendEntry(*(TLegendEntry*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TLegendEntry*) G__getstructoffset())->GetLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLegendEntry*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegendEntry*) G__getstructoffset())->SaveEntry(*(ostream*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TLegendEntry*) G__getstructoffset())->SetLabel((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TLegendEntry*) G__getstructoffset())->SetLabel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegendEntry*) G__getstructoffset())->SetObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegendEntry*) G__getstructoffset())->SetObject((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TLegendEntry*) G__getstructoffset())->SetOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TLegendEntry*) G__getstructoffset())->SetOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLegendEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLegendEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLegendEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLegendEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegendEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLegendEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLegendEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLegendEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_199_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLegendEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLegendEntry G__TTLegendEntry;
static int G__G__Graf_199_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[] (TLegendEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLegendEntry*) (soff+(sizeof(TLegendEntry)*i)))->~G__TTLegendEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLegendEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLegendEntry*) (soff))->~G__TTLegendEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLegend */
static int G__G__Graf_200_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLegend* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegend[n];
     } else {
       p = new((void*) gvp) TLegend[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegend;
     } else {
       p = new((void*) gvp) TLegend;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLegend));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLegend* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegend(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TLegend(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegend(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TLegend(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLegend(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TLegend(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLegend));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLegend* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLegend(*(TLegend*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TLegend(*(TLegend*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLegend));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TLegend*) G__getstructoffset())->AddEntry((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TLegend*) G__getstructoffset())->AddEntry((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TLegend*) G__getstructoffset())->AddEntry((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TLegend*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TLegend*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TLegend*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->DeleteEntry();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->EditEntryAttFill();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->EditEntryAttLine();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->EditEntryAttMarker();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->EditEntryAttText();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TLegend*) G__getstructoffset())->GetColumnSeparation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLegend*) G__getstructoffset())->GetEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TLegend*) G__getstructoffset())->GetEntrySeparation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TLegend*) G__getstructoffset())->GetHeader());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLegend*) G__getstructoffset())->GetListOfPrimitives());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TLegend*) G__getstructoffset())->GetMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TLegend*) G__getstructoffset())->GetNColumns());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TLegend*) G__getstructoffset())->GetNRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TLegend*) G__getstructoffset())->InsertEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TLegend*) G__getstructoffset())->InsertEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TLegend*) G__getstructoffset())->InsertEntry((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TLegend*) G__getstructoffset())->InsertEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->PaintPrimitives();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetDefaults();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetColumnSeparation((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetEntryLabel((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetEntryOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetEntrySeparation((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TLegend*) G__getstructoffset())->SetHeader((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TLegend*) G__getstructoffset())->SetHeader();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetMargin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->SetNColumns((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLegend::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLegend::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLegend::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLegend::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLegend*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLegend::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLegend::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLegend::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_200_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLegend::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLegend G__TTLegend;
static int G__G__Graf_200_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TLegend*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLegend*) (soff+(sizeof(TLegend)*i)))->~G__TTLegend();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLegend*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLegend*) (soff))->~G__TTLegend();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLink */
static int G__G__Graf_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLink* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLink[n];
     } else {
       p = new((void*) gvp) TLink[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLink;
     } else {
       p = new((void*) gvp) TLink;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLink));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLink* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLink(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (void*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLink(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (void*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLink));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLink::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLink::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLink::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLink::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLink*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLink::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLink::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLink::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLink::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLink* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLink(*(TLink*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TLink));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLink G__TTLink;
static int G__G__Graf_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TLink*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLink*) (soff+(sizeof(TLink)*i)))->~G__TTLink();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLink*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLink*) (soff))->~G__TTLink();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLink* dest = (TLink*) G__getstructoffset();
   *dest = *(TLink*) libp->para[0].ref;
   const TLink& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMarker */
static int G__G__Graf_203_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMarker[n];
     } else {
       p = new((void*) gvp) TMarker[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMarker;
     } else {
       p = new((void*) gvp) TMarker;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMarker(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TMarker(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMarker(*(TMarker*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMarker(*(TMarker*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMarker*) G__getstructoffset())->DrawMarker((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMarker*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMarker*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMarker*) G__getstructoffset())->PaintMarker((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMarker*) G__getstructoffset())->PaintMarkerNDC((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMarker*) G__getstructoffset())->SetNDC((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMarker*) G__getstructoffset())->SetNDC();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMarker*) G__getstructoffset())->SetX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMarker*) G__getstructoffset())->SetY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMarker::DisplayMarkerTypes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMarker::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMarker::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMarker::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMarker::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMarker*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMarker::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMarker::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMarker::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_203_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMarker::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMarker G__TTMarker;
static int G__G__Graf_203_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMarker*) (soff+(sizeof(TMarker)*i)))->~G__TTMarker();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMarker*) (soff))->~G__TTMarker();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_203_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMarker* dest = (TMarker*) G__getstructoffset();
   *dest = *(TMarker*) libp->para[0].ref;
   const TMarker& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPaveLabel */
static int G__G__Graf_205_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveLabel* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveLabel[n];
     } else {
       p = new((void*) gvp) TPaveLabel[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveLabel;
     } else {
       p = new((void*) gvp) TPaveLabel;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveLabel* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveLabel(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TPaveLabel(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveLabel(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TPaveLabel(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveLabel* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPaveLabel(*(TPaveLabel*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPaveLabel(*(TPaveLabel*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TPaveLabel*) G__getstructoffset())->DrawPaveLabel((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TPaveLabel*) G__getstructoffset())->DrawPaveLabel((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TPaveLabel*) G__getstructoffset())->GetLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TPaveLabel*) G__getstructoffset())->PaintPaveLabel((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TPaveLabel*) G__getstructoffset())->PaintPaveLabel((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveLabel*) G__getstructoffset())->SetLabel((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPaveLabel::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPaveLabel::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPaveLabel::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPaveLabel::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveLabel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPaveLabel::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPaveLabel::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPaveLabel::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_205_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPaveLabel::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPaveLabel G__TTPaveLabel;
static int G__G__Graf_205_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[] (TPaveLabel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPaveLabel*) (soff+(sizeof(TPaveLabel)*i)))->~G__TTPaveLabel();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPaveLabel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPaveLabel*) (soff))->~G__TTPaveLabel();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_205_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveLabel* dest = (TPaveLabel*) G__getstructoffset();
   *dest = *(TPaveLabel*) libp->para[0].ref;
   const TPaveLabel& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPaveStats */
static int G__G__Graf_206_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveStats* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveStats[n];
     } else {
       p = new((void*) gvp) TPaveStats[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveStats;
     } else {
       p = new((void*) gvp) TPaveStats;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPaveStats));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveStats* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveStats(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TPaveStats(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPaveStats(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TPaveStats(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPaveStats));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TPaveStats*) G__getstructoffset())->GetFitFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TPaveStats*) G__getstructoffset())->GetStatFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPaveStats*) G__getstructoffset())->GetOptFit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPaveStats*) G__getstructoffset())->GetOptStat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPaveStats*) G__getstructoffset())->GetParent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveStats*) G__getstructoffset())->SaveStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPaveStats*) G__getstructoffset())->SetFitFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPaveStats*) G__getstructoffset())->SetFitFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPaveStats*) G__getstructoffset())->SetStatFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPaveStats*) G__getstructoffset())->SetStatFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPaveStats*) G__getstructoffset())->SetOptFit((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPaveStats*) G__getstructoffset())->SetOptFit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPaveStats*) G__getstructoffset())->SetOptStat((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPaveStats*) G__getstructoffset())->SetOptStat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveStats*) G__getstructoffset())->SetParent((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPaveStats::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPaveStats::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPaveStats::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPaveStats::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPaveStats*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPaveStats::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPaveStats::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPaveStats::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_206_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPaveStats::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_206_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TPaveStats* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TPaveStats(*(TPaveStats*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPaveStats));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPaveStats G__TTPaveStats;
static int G__G__Graf_206_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPaveStats*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPaveStats*) (soff+(sizeof(TPaveStats)*i)))->~G__TTPaveStats();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPaveStats*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPaveStats*) (soff))->~G__TTPaveStats();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_206_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPaveStats* dest = (TPaveStats*) G__getstructoffset();
   *dest = *(TPaveStats*) libp->para[0].ref;
   const TPaveStats& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPavesText */
static int G__G__Graf_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPavesText* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPavesText[n];
     } else {
       p = new((void*) gvp) TPavesText[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPavesText;
     } else {
       p = new((void*) gvp) TPavesText;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPavesText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPavesText* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPavesText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TPavesText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPavesText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TPavesText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPavesText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TPavesText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPavesText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPavesText* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPavesText(*(TPavesText*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPavesText(*(TPavesText*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPavesText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPavesText*) G__getstructoffset())->GetNpaves());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPavesText*) G__getstructoffset())->SetNpaves((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPavesText*) G__getstructoffset())->SetNpaves();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPavesText::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPavesText::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPavesText::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPavesText::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPavesText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPavesText::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPavesText::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPavesText::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_207_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPavesText::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPavesText G__TTPavesText;
static int G__G__Graf_207_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[] (TPavesText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPavesText*) (soff+(sizeof(TPavesText)*i)))->~G__TTPavesText();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPavesText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPavesText*) (soff))->~G__TTPavesText();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_207_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPavesText* dest = (TPavesText*) G__getstructoffset();
   *dest = *(TPavesText*) libp->para[0].ref;
   const TPavesText& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPieSlice */
static int G__G__Graf_208_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPieSlice* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPieSlice[n];
     } else {
       p = new((void*) gvp) TPieSlice[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPieSlice;
     } else {
       p = new((void*) gvp) TPieSlice;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPieSlice));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPieSlice* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPieSlice(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TPie*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TPieSlice(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TPie*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPieSlice(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TPie*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TPieSlice(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TPie*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPieSlice));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPieSlice*) G__getstructoffset())->GetRadiusOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPieSlice*) G__getstructoffset())->GetValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSlice*) G__getstructoffset())->SetIsActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSlice*) G__getstructoffset())->SetRadiusOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSlice*) G__getstructoffset())->SetValue((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPieSlice::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieSlice::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPieSlice::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPieSlice::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPieSlice*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieSlice::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPieSlice::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPieSlice::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_208_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPieSlice::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_208_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TPieSlice* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TPieSlice(*(TPieSlice*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPieSlice));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPieSlice G__TTPieSlice;
static int G__G__Graf_208_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[] (TPieSlice*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPieSlice*) (soff+(sizeof(TPieSlice)*i)))->~G__TTPieSlice();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPieSlice*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPieSlice*) (soff))->~G__TTPieSlice();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPieSlice* dest = (TPieSlice*) G__getstructoffset();
   *dest = *(TPieSlice*) libp->para[0].ref;
   const TPieSlice& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPie */
static int G__G__Graf_209_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie[n];
     } else {
       p = new((void*) gvp) TPie[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie;
     } else {
       p = new((void*) gvp) TPie;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPie));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPie));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]), (const char**) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]), (const char**) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPie));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]), (const char**) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]), (const char**) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TPie(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPie));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPie((TH1*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TPie((TH1*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPie));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPie(*(TPie*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPie(*(TPie*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPie));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->DistancetoSlice((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TPie*) G__getstructoffset())->GetAngle3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetAngularOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->GetEntryFillColor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->GetEntryFillStyle((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TPie*) G__getstructoffset())->GetEntryLabel((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->GetEntryLineColor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->GetEntryLineStyle((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->GetEntryLineWidth((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetEntryRadiusOffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetEntryVal((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TPie*) G__getstructoffset())->GetFractionFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TPie*) G__getstructoffset())->GetLabelFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TPie*) G__getstructoffset())->GetLabelsOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->GetLegend());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPie*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TPie*) G__getstructoffset())->GetPercentFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->GetSlice((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TPie*) G__getstructoffset())->GetValueFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPie*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->MakeLegend((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const char*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->MakeLegend((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->MakeLegend((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->MakeLegend((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->MakeLegend((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TPie*) G__getstructoffset())->MakeLegend());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPie*) G__getstructoffset())->MakeSlices((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPie*) G__getstructoffset())->MakeSlices();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPie*) G__getstructoffset())->SetAngle3D((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPie*) G__getstructoffset())->SetAngle3D();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetAngularOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TPie*) G__getstructoffset())->SetCircle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TPie*) G__getstructoffset())->SetCircle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPie*) G__getstructoffset())->SetCircle((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPie*) G__getstructoffset())->SetCircle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TPie*) G__getstructoffset())->SetEntryLabel((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPie*) G__getstructoffset())->SetEntryLabel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryLineColor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryLineStyle((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryLineWidth((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryFillColor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryFillStyle((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryRadiusOffset((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetEntryVal((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetFillColors((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetFractionFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPie*) G__getstructoffset())->SetHeight((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPie*) G__getstructoffset())->SetHeight();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetLabelFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetLabels((const char**) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetLabelsOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetPercentFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetRadius((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetValueFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->SetY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TPie*) G__getstructoffset())->SortSlices((Bool_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPie*) G__getstructoffset())->SortSlices((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPie*) G__getstructoffset())->SortSlices();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPie::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPie::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPie::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPie::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPie*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPie::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPie::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPie::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_209_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPie::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPie G__TTPie;
static int G__G__Graf_209_0_74(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[] (TPie*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPie*) (soff+(sizeof(TPie)*i)))->~G__TTPie();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPie*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPie*) (soff))->~G__TTPie();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_209_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPie* dest = (TPie*) G__getstructoffset();
   *dest = *(TPie*) libp->para[0].ref;
   const TPie& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPoints */
static int G__G__Graf_210_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoints* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPoints[n];
     } else {
       p = new((void*) gvp) TPoints[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPoints;
     } else {
       p = new((void*) gvp) TPoints;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPoints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoints* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPoints((Double_t) G__double(libp->para[0]));
   } else {
     p = new((void*) gvp) TPoints((Double_t) G__double(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPoints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoints* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPoints((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
   } else {
     p = new((void*) gvp) TPoints((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPoints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TPoints*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TPoints*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoints*) G__getstructoffset())->SetX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoints*) G__getstructoffset())->SetY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPoints::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPoints::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPoints::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPoints::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPoints*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoints*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoints*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoints*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPoints::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPoints::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPoints::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_210_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPoints::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_210_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TPoints* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TPoints(*(TPoints*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TPoints));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPoints G__TTPoints;
static int G__G__Graf_210_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPoints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPoints*) (soff+(sizeof(TPoints)*i)))->~G__TTPoints();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPoints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPoints*) (soff))->~G__TTPoints();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_210_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoints* dest = (TPoints*) G__getstructoffset();
   *dest = *(TPoints*) libp->para[0].ref;
   const TPoints& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTF */
static int G__G__Graf_218_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTF::CharToUnicode((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::LayoutGlyphs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::PrepareString((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::SetRotationMatrix((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTF* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTF[n];
     } else {
       p = new((void*) gvp) TTF[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTF;
     } else {
       p = new((void*) gvp) TTF;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TTF));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::Cleanup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTF::GetAscent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const FT_BBox& obj = TTF::GetBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTF::GetGlyphs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TTF::GetHinting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TTF::GetKerning());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTF::GetNumGlyphs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTF::GetRotMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TTF::GetSmoothing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTF::GetWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::SetHinting((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::SetKerning((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::SetSmoothing((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::GetTextExtent(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, (char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::GetTextAdvance(*(UInt_t*) G__UIntref(&libp->para[0]), (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::SetTextFont((Font_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) TTF::SetTextFont((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) TTF::SetTextFont((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::SetTextSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TTF::IsInitialized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::Version(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTF::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTF::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTF::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTF::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTF*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTF*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTF*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTF*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTF::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTF::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTF::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf_218_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTF::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Graf_218_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTF* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTF(*(TTF*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GrafLN_TTF));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTF G__TTTF;
static int G__G__Graf_218_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTF*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTF*) (soff+(sizeof(TTF)*i)))->~G__TTTF();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTF*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTF*) (soff))->~G__TTTF();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Graf_218_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTF* dest = (TTF*) G__getstructoffset();
   *dest = *(TTF*) libp->para[0].ref;
   const TTF& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Graf__0_343(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TImage* pobj;
         TImage xobj = operator+(*(TImage*) libp->para[0].ref, *(TImage*) libp->para[1].ref);
         pobj = new TImage(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Graf__0_344(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TImage* pobj;
         TImage xobj = operator/(*(TImage*) libp->para[0].ref, *(TImage*) libp->para[1].ref);
         pobj = new TImage(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TEllipse */

/* TArc */

/* TLine */

/* TArrow */

/* TAttImage */

/* TPaletteEditor */

/* TImagePalette */

/* TBox */

/* TCrown */

/* TPolyLine */

/* TCurlyLine */

/* TCurlyArc */

/* TCutG */

/* TPave */

/* TText */

/* TPaveText */

/* TDiamond */

/* TWbox */

/* TFrame */

/* TGaxis */

/* TGraphPolargram */

/* TGraphPolar */

/* TGraphQQ */

/* TImage */

/* TImagePlugin */

/* TLatex */

/* TLegendEntry */

/* TLegend */

/* TLink */

/* TMarker */

/* TPaveLabel */

/* TPaveStats */

/* TPavesText */

/* TPieSlice */

/* TPie */

/* TPoints */

/* TTF */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Graf {
 public:
  G__Sizep2memfuncG__Graf(): p(&G__Sizep2memfuncG__Graf::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Graf::*p)();
};

size_t G__get_sizep2memfuncG__Graf()
{
  G__Sizep2memfuncG__Graf 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__Graf() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TEllipse))) {
     TEllipse *G__Lderived;
     G__Lderived=(TEllipse*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TEllipse),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TEllipse),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TEllipse),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TArc))) {
     TArc *G__Lderived;
     G__Lderived=(TArc*)0x1000;
     {
       TEllipse *G__Lpbase=(TEllipse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArc),G__get_linked_tagnum(&G__G__GrafLN_TEllipse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArc),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArc),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArc),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TLine))) {
     TLine *G__Lderived;
     G__Lderived=(TLine*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLine),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLine),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TArrow))) {
     TArrow *G__Lderived;
     G__Lderived=(TArrow*)0x1000;
     {
       TLine *G__Lpbase=(TLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArrow),G__get_linked_tagnum(&G__G__GrafLN_TLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArrow),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArrow),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TArrow),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TImagePalette))) {
     TImagePalette *G__Lderived;
     G__Lderived=(TImagePalette*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TImagePalette),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TBox))) {
     TBox *G__Lderived;
     G__Lderived=(TBox*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TBox),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TBox),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TBox),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TCrown))) {
     TCrown *G__Lderived;
     G__Lderived=(TCrown*)0x1000;
     {
       TEllipse *G__Lpbase=(TEllipse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCrown),G__get_linked_tagnum(&G__G__GrafLN_TEllipse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCrown),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCrown),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCrown),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPolyLine))) {
     TPolyLine *G__Lderived;
     G__Lderived=(TPolyLine*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPolyLine),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPolyLine),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPolyLine),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine))) {
     TCurlyLine *G__Lderived;
     G__Lderived=(TCurlyLine*)0x1000;
     {
       TPolyLine *G__Lpbase=(TPolyLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine),G__get_linked_tagnum(&G__G__GrafLN_TPolyLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc))) {
     TCurlyArc *G__Lderived;
     G__Lderived=(TCurlyArc*)0x1000;
     {
       TCurlyLine *G__Lpbase=(TCurlyLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc),G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPolyLine *G__Lpbase=(TPolyLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc),G__get_linked_tagnum(&G__G__GrafLN_TPolyLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TCutG))) {
     TCutG *G__Lderived;
     G__Lderived=(TCutG*)0x1000;
     {
       TGraph *G__Lpbase=(TGraph*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG),G__get_linked_tagnum(&G__G__GrafLN_TGraph),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG),G__get_linked_tagnum(&G__G__GrafLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPave))) {
     TPave *G__Lderived;
     G__Lderived=(TPave*)0x1000;
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPave),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPave),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPave),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPave),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TText))) {
     TText *G__Lderived;
     G__Lderived=(TText*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TText),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TText),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TText),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPaveText))) {
     TPaveText *G__Lderived;
     G__Lderived=(TPaveText*)0x1000;
     {
       TPave *G__Lpbase=(TPave*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText),G__get_linked_tagnum(&G__G__GrafLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TDiamond))) {
     TDiamond *G__Lderived;
     G__Lderived=(TDiamond*)0x1000;
     {
       TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPave *G__Lpbase=(TPave*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TWbox))) {
     TWbox *G__Lderived;
     G__Lderived=(TWbox*)0x1000;
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TWbox),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TWbox),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TWbox),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TWbox),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TFrame))) {
     TFrame *G__Lderived;
     G__Lderived=(TFrame*)0x1000;
     {
       TWbox *G__Lpbase=(TWbox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame),G__get_linked_tagnum(&G__G__GrafLN_TWbox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TGaxis))) {
     TGaxis *G__Lderived;
     G__Lderived=(TGaxis*)0x1000;
     {
       TLine *G__Lpbase=(TLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGaxis),G__get_linked_tagnum(&G__G__GrafLN_TLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGaxis),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGaxis),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGaxis),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram))) {
     TGraphPolargram *G__Lderived;
     G__Lderived=(TGraphPolargram*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar))) {
     TGraphPolar *G__Lderived;
     G__Lderived=(TGraphPolar*)0x1000;
     {
       TGraphErrors *G__Lpbase=(TGraphErrors*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TGraphErrors),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGraph *G__Lpbase=(TGraph*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TGraph),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar),G__get_linked_tagnum(&G__G__GrafLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ))) {
     TGraphQQ *G__Lderived;
     G__Lderived=(TGraphQQ*)0x1000;
     {
       TGraph *G__Lpbase=(TGraph*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ),G__get_linked_tagnum(&G__G__GrafLN_TGraph),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ),G__get_linked_tagnum(&G__G__GrafLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TImage))) {
     TImage *G__Lderived;
     G__Lderived=(TImage*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TImage),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TImage),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttImage *G__Lpbase=(TAttImage*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TImage),G__get_linked_tagnum(&G__G__GrafLN_TAttImage),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TImagePlugin))) {
     TImagePlugin *G__Lderived;
     G__Lderived=(TImagePlugin*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TImagePlugin),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TLatex))) {
     TLatex *G__Lderived;
     G__Lderived=(TLatex*)0x1000;
     {
       TText *G__Lpbase=(TText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex),G__get_linked_tagnum(&G__G__GrafLN_TText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry))) {
     TLegendEntry *G__Lderived;
     G__Lderived=(TLegendEntry*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry),G__get_linked_tagnum(&G__G__GrafLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TLegend))) {
     TLegend *G__Lderived;
     G__Lderived=(TLegend*)0x1000;
     {
       TPave *G__Lpbase=(TPave*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend),G__get_linked_tagnum(&G__G__GrafLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TLink))) {
     TLink *G__Lderived;
     G__Lderived=(TLink*)0x1000;
     {
       TText *G__Lpbase=(TText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLink),G__get_linked_tagnum(&G__G__GrafLN_TText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLink),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLink),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TLink),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TMarker))) {
     TMarker *G__Lderived;
     G__Lderived=(TMarker*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TMarker),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TMarker),G__get_linked_tagnum(&G__G__GrafLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel))) {
     TPaveLabel *G__Lderived;
     G__Lderived=(TPaveLabel*)0x1000;
     {
       TPave *G__Lpbase=(TPave*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel),G__get_linked_tagnum(&G__G__GrafLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats))) {
     TPaveStats *G__Lderived;
     G__Lderived=(TPaveStats*)0x1000;
     {
       TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPave *G__Lpbase=(TPave*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPavesText))) {
     TPavesText *G__Lderived;
     G__Lderived=(TPavesText*)0x1000;
     {
       TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPave *G__Lpbase=(TPave*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBox *G__Lpbase=(TBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice))) {
     TPieSlice *G__Lderived;
     G__Lderived=(TPieSlice*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice),G__get_linked_tagnum(&G__G__GrafLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice),G__get_linked_tagnum(&G__G__GrafLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GrafLN_TPie))) {
     TPie *G__Lderived;
     G__Lderived=(TPie*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPie),G__get_linked_tagnum(&G__G__GrafLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPie),G__get_linked_tagnum(&G__G__GrafLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GrafLN_TPie),G__get_linked_tagnum(&G__G__GrafLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Graf() {

   /* Setting up typedef entry */
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   G__search_typename2("UShort_t",114,-1,0,-1);
   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Font_t",115,-1,0,-1);
   G__setnewtype(-1,"Font number (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__GrafLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GrafLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GrafLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GrafLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GrafLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__GrafLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GrafLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GrafLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GrafLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GrafLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__GrafLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__GrafLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorD",117,G__get_linked_tagnum(&G__G__GrafLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Pixmap_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixmap handle",0);
   G__search_typename2("Drawable_t",107,-1,0,-1);
   G__setnewtype(-1,"Drawable handle",0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TEllipse */
static void G__setup_memvarTEllipse(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TEllipse));
   { TEllipse *p; p=(TEllipse*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1=",0,"X coordinate of centre");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1=",0,"Y coordinate of centre");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fR1=",0,"first radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fR2=",0,"second radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhimin=",0,"Minimum angle (degrees)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhimax=",0,"Maximum angle (degrees)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta=",0,"Rotation angle (degrees)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TEllipsecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoEdges=%lldLL",(long long)TEllipse::kNoEdges).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArc */
static void G__setup_memvarTArc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TArc));
   { TArc *p; p=(TArc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLine */
static void G__setup_memvarTLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TLine));
   { TLine *p; p=(TLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1=",0,"X of 1st point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1=",0,"Y of 1st point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2=",0,"X of 2nd point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2=",0,"Y of 2nd point");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TLinecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLineNDC=%lldLL",(long long)TLine::kLineNDC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TLinecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kVertical=%lldLL",(long long)TLine::kVertical).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TLinecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kHorizontal=%lldLL",(long long)TLine::kHorizontal).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrow */
static void G__setup_memvarTArrow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TArrow));
   { TArrow *p; p=(TArrow*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAngle=",0,"Arrow opening angle (degrees)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fArrowSize=",0,"Arrow Size");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fOption=",0,"Arrow shapes");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,2,"fgDefaultAngle=",0,"default Arrow opening angle (degrees)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,2,"fgDefaultArrowSize=",0,"default Arrow Size");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-2,2,"fgDefaultOption=",0,"default Arrow shapes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TAttImage */
static void G__setup_memvarTAttImage(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TAttImage));
   { TAttImage *p; p=(TAttImage*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality),-1,-2,1,G__FastAllocString(2048).Format("kImgDefault=%lldLL",(long long)TAttImage::kImgDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality),-1,-2,1,G__FastAllocString(2048).Format("kImgPoor=%lldLL",(long long)TAttImage::kImgPoor).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality),-1,-2,1,G__FastAllocString(2048).Format("kImgFast=%lldLL",(long long)TAttImage::kImgFast).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality),-1,-2,1,G__FastAllocString(2048).Format("kImgGood=%lldLL",(long long)TAttImage::kImgGood).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality),-1,-2,1,G__FastAllocString(2048).Format("kImgBest=%lldLL",(long long)TAttImage::kImgBest).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality),-1,-1,2,"fImageQuality=",0,"*OPTION={GetMethod=\"GetImageQuality\";SetMethod=\"SetImageQuality\";Items=(kImgDefault=\"Default\",kImgPoor=\"Poor\",kImgFast=\"Fast\",kImgGood=\"Good\",kImgBest=\"Best\")}*");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fImageCompression=",0,"compression [0 .. 100] 0: no compression");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fConstRatio=",0,"keep aspect ratio of image on the screen");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TImagePalette),-1,-1,2,"fPalette=",0,"color palette for value -> color conversion");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TPaletteEditor),-1,-1,2,"fPaletteEditor=",0,"! GUI to edit the color palette");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPaletteEnabled=",0,"! kTRUE - palette is drawn on the image");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPaletteEditor */
static void G__setup_memvarTPaletteEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaletteEditor));
   { TPaletteEditor *p; p=(TPaletteEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TAttImage),-1,-1,2,"fAttImage=",0,"image attributes to be edited");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TImagePalette */
static void G__setup_memvarTImagePalette(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TImagePalette));
   { TImagePalette *p; p=(TImagePalette*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fNumPoints)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fNumPoints=",0,"number of anchor points");
   G__memvar_setup((void*)((long)(&p->fPoints)-(long)(p)),68,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPoints=",0,"[fNumPoints] value of each anchor point [0..1]");
   G__memvar_setup((void*)((long)(&p->fColorRed)-(long)(p)),82,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fColorRed=",0,"[fNumPoints] red color at each anchor point");
   G__memvar_setup((void*)((long)(&p->fColorGreen)-(long)(p)),82,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fColorGreen=",0,"[fNumPoints] green color at each anchor point");
   G__memvar_setup((void*)((long)(&p->fColorBlue)-(long)(p)),82,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fColorBlue=",0,"[fNumPoints] blue color at each anchor point");
   G__memvar_setup((void*)((long)(&p->fColorAlpha)-(long)(p)),82,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fColorAlpha=",0,"[fNumPoints] alpha at each anchor point");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBox */
static void G__setup_memvarTBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TBox));
   { TBox *p; p=(TBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TObject),-1,-1,4,"fTip=",0,"!tool tip associated with box");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1=",0,"X of 1st point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1=",0,"Y of 1st point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2=",0,"X of 2nd point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2=",0,"Y of 2nd point");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fResizing=",0,"!True if box is being resized");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TBoxcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCannotMove=%lldLL",(long long)TBox::kCannotMove).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCrown */
static void G__setup_memvarTCrown(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TCrown));
   { TCrown *p; p=(TCrown*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPolyLine */
static void G__setup_memvarTPolyLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPolyLine));
   { TPolyLine *p; p=(TPolyLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"Number of points");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastPoint=",0,"The index of the last filled point");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"[fN] Array of X coordinates");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"[fN] Array of Y coordinates");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fOption=",0,"options");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TPolyLinecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kPolyLineNDC=%lldLL",(long long)TPolyLine::kPolyLineNDC).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCurlyLine */
static void G__setup_memvarTCurlyLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine));
   { TCurlyLine *p; p=(TCurlyLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1=",0,"start x, center for arc");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1=",0,"start y, center for arc");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2=",0,"end x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2=",0,"end y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWaveLength=",0,"wavelength of sinusoid in percent of pad height");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAmplitude=",0,"amplitude of sinusoid in percent of pad height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsteps=",0,"used internally (controls precision)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsCurly=",0,"true: Gluon, false: Gamma");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,2,"fgDefaultWaveLength=",0,"default wavelength");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,2,"fgDefaultAmplitude=",0,"default amplitude");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgDefaultIsCurly=",0,"default curly type");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TCurlyLinecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTooShort=%lldLL",(long long)TCurlyLine::kTooShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCurlyArc */
static void G__setup_memvarTCurlyArc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc));
   { TCurlyArc *p; p=(TCurlyArc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fR1=",0,"Radius of arc");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhimin=",0,"start phi (degrees)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhimax=",0,"end phi (degrees)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTheta=",0,"used internally");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fgDefaultWaveLength=",0,"default wavelength ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fgDefaultAmplitude=",0,"default amplitude");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgDefaultIsCurly=",0,"default curly type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCutG */
static void G__setup_memvarTCutG(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG));
   { TCutG *p; p=(TCutG*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fVarX=",0,"X variable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fVarY=",0,"Y variable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TObject),-1,-1,2,"fObjectX=",0,"!pointer to an object corresponding to X");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TObject),-1,-1,2,"fObjectY=",0,"!pointer to an object corresponding to Y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPave */
static void G__setup_memvarTPave(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPave));
   { TPave *p; p=(TPave*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1NDC=",0,"X1 point in NDC coordinates");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1NDC=",0,"Y1 point in NDC coordinates");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2NDC=",0,"X2 point in NDC coordinates");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2NDC=",0,"Y2 point in NDC coordinates");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBorderSize=",0,"window box bordersize in pixels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInit=",0,"(=0 if transformation to NDC not yet done)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fShadowColor=",0,"Color of the pave's shadow");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCornerRadius=",0,"Corner radius in case of option arc");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fOption=",0,"Pave style");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fName=",0,"Pave name");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TPavecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNameIsAction=%lldLL",(long long)TPave::kNameIsAction).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TText */
static void G__setup_memvarTText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TText));
   { TText *p; p=(TText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"X position of text (left,center,etc..)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"Y position of text (left,center,etc..)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TTextcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTextNDC=%lldLL",(long long)TText::kTextNDC).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPaveText */
static void G__setup_memvarTPaveText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText));
   { TPaveText *p; p=(TPaveText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fLabel=",0,"Label written at the top of the pavetext");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLongest=",0,"Length of the longest line");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMargin=",0,"Text margin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TList),-1,-1,2,"fLines=",0,"List of labels");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDiamond */
static void G__setup_memvarTDiamond(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond));
   { TDiamond *p; p=(TDiamond*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TWbox */
static void G__setup_memvarTWbox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TWbox));
   { TWbox *p; p=(TWbox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fBorderSize=",0,"window box bordersize in pixels");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fBorderMode=",0,"Bordermode (-1=down, 0 = no border, 1=up)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFrame */
static void G__setup_memvarTFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame));
   { TFrame *p; p=(TFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGaxis */
static void G__setup_memvarTGaxis(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TGaxis));
   { TGaxis *p; p=(TGaxis*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWmin=",0,"Lowest value on the axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWmax=",0,"Highest value on the axis");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fGridLength=",0,"Length of the grid in NDC");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTickSize=",0,"Size of primary tick mark in NDC");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLabelOffset=",0,"Offset of label wrt axis");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLabelSize=",0,"Size of labels in NDC");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTitleOffset=",0,"Offset of title wrt axis");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTitleSize=",0,"Size of title in NDC");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiv=",0,"Number of divisions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLabelColor=",0,"Color for labels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLabelFont=",0,"Font for labels");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fChopt=",0,"Axis options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fName=",0,"axis name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fTitle=",0,"axis title");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fTimeFormat=",0,"Time format, ex: 09/12/99 12:34:00");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fFunctionName=",0,"name of mapping function pointed by fFunction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TF1),-1,-1,2,"fFunction=",0,"!Pointer to function computing axis values");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TAxis),-1,-1,2,"fAxis=",0,"!pointer to original TAxis axis (if any)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgMaxDigits=",0,"!Number of digits above which the 10>N notation is used");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphPolargram */
static void G__setup_memvarTGraphPolargram(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram));
   { TGraphPolargram *p; p=(TGraphPolargram*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRadian=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDegree=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fGrad=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fPolarLabelColor=",0,"Set color of the angular labels");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fRadialLabelColor=",0,"Set color of the radial labels");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAxisAngle=",0,"Set angle of the radial axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPolarOffset=",0,"Offset for Polar labels");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPolarTextSize=",0,"Set Polar text size");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRadialOffset=",0,"Offset for radial labels");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRadialTextSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRwrmin=",0,"Minimal radial value (real world)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRwrmax=",0,"Maximal radial value (real world)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRwtmin=",0,"Minimal angular value (real world)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRwtmax=",0,"Minimal angular value (real world)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTickpolarSize=",0,"Set size of Tickmarks");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Font_t"),-1,4,"fPolarLabelFont=",0,"Set font of angular labels");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Font_t"),-1,4,"fRadialLabelFont=",0,"Set font of radial labels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCutRadial=",0,"if fCutRadial = 0, circles are cut by radial axis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdivRad=",0,"Number of radial divisions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdivPol=",0,"Number of polar divisions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,4,"fPolarLabels=",0,"![fNdivPol] Specified polar labels");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargramcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLabelOrtho=%lldLL",(long long)TGraphPolargram::kLabelOrtho).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphPolar */
static void G__setup_memvarTGraphPolar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar));
   { TGraphPolar *p; p=(TGraphPolar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fOptionAxis=",0,"Force drawing of new coord system");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram),-1,-1,2,"fPolargram=",0,"The polar coordinates system");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXpol=",0,"[fNpoints] points in polar coordinates");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYpol=",0,"[fNpoints] points in polar coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphQQ */
static void G__setup_memvarTGraphQQ(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ));
   { TGraphQQ *p; p=(TGraphQQ*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNy0=",0,"size of the fY0 dataset");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXq1=",0,"x1 coordinate of the interquartile line");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXq2=",0,"x2 coordinate of the interquartile line");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYq1=",0,"y1 coordinate of the interquartile line");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYq2=",0,"y2 coordinate of the interquartile line");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY0=",0,"!second dataset, if specified");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TF1),-1,-1,2,"fF=",0,"theoretical density function, if specified");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TImage */
static void G__setup_memvarTImage(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TImage));
   { TImage *p; p=(TImage*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kXpm=%lldLL",(long long)TImage::kXpm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kZCompressedXpm=%lldLL",(long long)TImage::kZCompressedXpm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kGZCompressedXpm=%lldLL",(long long)TImage::kGZCompressedXpm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kPng=%lldLL",(long long)TImage::kPng).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kJpeg=%lldLL",(long long)TImage::kJpeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kXcf=%lldLL",(long long)TImage::kXcf).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kPpm=%lldLL",(long long)TImage::kPpm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kPnm=%lldLL",(long long)TImage::kPnm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kBmp=%lldLL",(long long)TImage::kBmp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kIco=%lldLL",(long long)TImage::kIco).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kCur=%lldLL",(long long)TImage::kCur).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kGif=%lldLL",(long long)TImage::kGif).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kTiff=%lldLL",(long long)TImage::kTiff).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kXbm=%lldLL",(long long)TImage::kXbm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kFits=%lldLL",(long long)TImage::kFits).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kTga=%lldLL",(long long)TImage::kTga).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kXml=%lldLL",(long long)TImage::kXml).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kUnknown=%lldLL",(long long)TImage::kUnknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes),-1,-2,1,G__FastAllocString(2048).Format("kAnimGif=%lldLL",(long long)TImage::kAnimGif).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kPlain=%lldLL",(long long)TImage::kPlain).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kEmbossed=%lldLL",(long long)TImage::kEmbossed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kSunken=%lldLL",(long long)TImage::kSunken).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kShadeAbove=%lldLL",(long long)TImage::kShadeAbove).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kShadeBelow=%lldLL",(long long)TImage::kShadeBelow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kEmbossedThick=%lldLL",(long long)TImage::kEmbossedThick).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kSunkenThick=%lldLL",(long long)TImage::kSunkenThick).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kOutlineAbove=%lldLL",(long long)TImage::kOutlineAbove).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kOutlineBelow=%lldLL",(long long)TImage::kOutlineBelow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("kOutlineFull=%lldLL",(long long)TImage::kOutlineFull).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEText3DType),-1,-2,1,G__FastAllocString(2048).Format("k3DTypes=%lldLL",(long long)TImage::k3DTypes).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLECharType),-1,-2,1,G__FastAllocString(2048).Format("kUTF8=%lldLL",(long long)TImage::kUTF8).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLECharType),-1,-2,1,G__FastAllocString(2048).Format("kChar=%lldLL",(long long)TImage::kChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLECharType),-1,-2,1,G__FastAllocString(2048).Format("kUnicode=%lldLL",(long long)TImage::kUnicode).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLETileType),-1,-2,1,G__FastAllocString(2048).Format("kStretch=%lldLL",(long long)TImage::kStretch).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLETileType),-1,-2,1,G__FastAllocString(2048).Format("kTile=%lldLL",(long long)TImage::kTile).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLETileType),-1,-2,1,G__FastAllocString(2048).Format("kStretchY=%lldLL",(long long)TImage::kStretchY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLETileType),-1,-2,1,G__FastAllocString(2048).Format("kStretchX=%lldLL",(long long)TImage::kStretchX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLECoordMode),-1,-2,1,G__FastAllocString(2048).Format("kCoordModeOrigin=%lldLL",(long long)TImage::kCoordModeOrigin).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLECoordMode),-1,-2,1,G__FastAllocString(2048).Format("kCoordModePrevious=%lldLL",(long long)TImage::kCoordModePrevious).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEColorChan),-1,-2,1,G__FastAllocString(2048).Format("kRedChan=%lldLL",(long long)TImage::kRedChan).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEColorChan),-1,-2,1,G__FastAllocString(2048).Format("kGreenChan=%lldLL",(long long)TImage::kGreenChan).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEColorChan),-1,-2,1,G__FastAllocString(2048).Format("kBlueChan=%lldLL",(long long)TImage::kBlueChan).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEColorChan),-1,-2,1,G__FastAllocString(2048).Format("kAlphaChan=%lldLL",(long long)TImage::kAlphaChan).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEColorChan),-1,-2,1,G__FastAllocString(2048).Format("kAllChan=%lldLL",(long long)TImage::kAllChan).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TImagePlugin */
static void G__setup_memvarTImagePlugin(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TImagePlugin));
   { TImagePlugin *p; p=(TImagePlugin*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fExtension=",0,"file extension");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLatex */
static void G__setup_memvarTLatex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex));
   { TLatex *p; p=(TLatex*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFactorSize=",0,"!Relative size of subscripts and superscripts");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFactorPos=",0,"!Relative position of subscripts and superscripts");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLimitFactorSize=",0,"lower bound for subscripts/superscripts size");
   G__memvar_setup((void*)0,67,0,1,-1,G__defined_typename("Char_t"),-1,2,"fError=",0,"!error code");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShow=",0,"!is true during the second pass (Painting)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_FormSize_t),-1,-1,2,"fTabSize=",0,"!array of values for the different zones");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOriginSize=",0,"Font size of the starting font");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTabMax=",0,"!Maximum allocation for array fTabSize;");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPos=",0,"!Current position in array fTabSize;");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fItalic=",0,"!Currently inside #it operator");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TLatexcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTextNDC=%lldLL",(long long)TLatex::kTextNDC).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLegendEntry */
static void G__setup_memvarTLegendEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry));
   { TLegendEntry *p; p=(TLegendEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TObject),-1,-1,2,"fObject=",0,"pointer to object being represented by this entry");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fLabel=",0,"Text associated with the entry, will become latex");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fOption=",0,"Options associated with this entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLegend */
static void G__setup_memvarTLegend(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend));
   { TLegend *p; p=(TLegend*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TList),-1,-1,2,"fPrimitives=",0,"list of TLegendEntries");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEntrySeparation=",0,"separation between entries, as a fraction of");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMargin=",0,"fraction of total width used for symbol");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNColumns=",0,"number of columns in the legend");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fColumnSeparation=",0,"separation between columns, as a fraction of ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLink */
static void G__setup_memvarTLink(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TLink));
   { TLink *p; p=(TLink*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fLink=",0,"pointer to object");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TLinkcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kObjIsParent=%lldLL",(long long)TLink::kObjIsParent).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TLinkcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsStarStar=%lldLL",(long long)TLink::kIsStarStar).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMarker */
static void G__setup_memvarTMarker(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TMarker));
   { TMarker *p; p=(TMarker*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"X position of marker (left,center,etc..)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"Y position of marker (left,center,etc..)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TMarkercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kMarkerNDC=%lldLL",(long long)TMarker::kMarkerNDC).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPaveLabel */
static void G__setup_memvarTPaveLabel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel));
   { TPaveLabel *p; p=(TPaveLabel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fLabel=",0,"Label written at the center of Pave");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPaveStats */
static void G__setup_memvarTPaveStats(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats));
   { TPaveStats *p; p=(TPaveStats*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOptFit=",0,"option Fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOptStat=",0,"option Stat");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fFitFormat=",0,"Printing format for fit parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fStatFormat=",0,"Printing format for stats");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TObject),-1,-1,2,"fParent=",0,"owner of this TPaveStats");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPavesText */
static void G__setup_memvarTPavesText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText));
   { TPavesText *p; p=(TPavesText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpaves=",0,"Number of stacked paves");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPieSlice */
static void G__setup_memvarTPieSlice(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice));
   { TPieSlice *p; p=(TPieSlice*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsActive=",0,"! True if is the slice under the mouse pointer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TPie),-1,-1,2,"fPie=",0,"The TPie object that contain this slice");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fValue=",0,"value value of this slice");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRadiusOffset=",0,"roffset offset from the center of the pie");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPie */
static void G__setup_memvarTPie(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPie));
   { TPie *p; p=(TPie*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSum=",0,"!Sum for the slice values");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSlices=",0,"!Subdivisions of the slices");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TLegend),-1,-1,4,"fLegend=",0,"!Legend for this piechart");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"X coordinate of the pie centre");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"Y coordinate of the pie centre");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRadius=",0,"Radius Pie radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngularOffset=",0,"Offset angular offset for the first slice");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLabelsOffset=",0,"LabelsOffset offset of label");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fLabelFormat=",0,"Format format of the slices' label");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fValueFormat=",0,"Vform numeric format for the value");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fFractionFormat=",0,"Rform numeric format for the fraction of a slice");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TString),-1,-1,2,"fPercentFormat=",0,"Pfrom numeric format for the percent of a slice");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNvals=",0,"Number of elements");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GrafLN_TPieSlice),-1,-1,2,"fPieSlices=",0,"[fNvals] Slice array of this pie-chart");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIs3D=",0,"! true if the pseudo-3d is enabled");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fHeight=",0,"Pheight height of the slice in pixel");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAngle3D=",0,"The angle of the pseudo-3d view");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPoints */
static void G__setup_memvarTPoints(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TPoints));
   { TPoints *p; p=(TPoints*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fX=",0,"X world coordinate");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fY=",0,"Y world coordinate");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTF */
static void G__setup_memvarTTF(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GrafLN_TTF));
   { TTF *p; p=(TTF*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TTFcLcLdA),-1,-2,4,"kTTMaxFonts=32LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GrafLN_TTFcLcLdA),-1,-2,4,"kMaxGlyphs=1024LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgAscent=",0,"string ascent, used to compute Y alignment");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_FT_BBox),-1,-2,4,"fgCBox=",0,"string control box");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("FT_CharMap"),-2,4,"fgCharMap[32]=",0,"font character map");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgCurFontIdx=",0,"current font index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgSymbItaFontIdx=",0,"Symbol italic font index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgFontCount=",0,"number of fonts loaded");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-2,4,"fgFontName[32]=",0,"font name");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("FT_Face"),-2,4,"fgFace[32]=",0,"font face");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GrafLN_TTGlyph),-1,-2,4,"fgGlyphs[1024]=",0,"glyphs");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgHinting=",0,"use hinting (true by default)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgInit=",0,"true if the Init has been called");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgKerning=",0,"use kerning (true by default)");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("FT_Library"),-2,4,"fgLibrary=",0,"FreeType font library");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgNumGlyphs=",0,"number of glyphs in the string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_FT_Matrix),-1,-2,4,"fgRotMatrix=",0,"rotation matrix");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgSmoothing=",0,"use anti-aliasing (true when >8 planes, false otherwise)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgTBlankW=",0,"trailing blanks width");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgWidth=",0,"string width, used to compute X alignment");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Graf() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTEllipse(void) {
   /* TEllipse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TEllipse));
   G__memfunc_setup("TEllipse",802,G__G__Graf_102_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TEllipse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEllipse",802,G__G__Graf_102_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TEllipse), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - r1 d - 'Double_t' 0 '0' r2 "
"d - 'Double_t' 0 '0' phimin d - 'Double_t' 0 '360' phimax "
"d - 'Double_t' 0 '0' theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEllipse",802,G__G__Graf_102_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TEllipse), -1, 0, 1, 1, 1, 0, "u 'TEllipse' - 11 - ellipse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - ellipse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawEllipse",1116,G__G__Graf_102_0_7, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - r1 d - 'Double_t' 0 - r2 "
"d - 'Double_t' 0 - phimin d - 'Double_t' 0 - phimax "
"d - 'Double_t' 0 - theta C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX1",425,G__G__Graf_102_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY1",426,G__G__Graf_102_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetR1",419,G__G__Graf_102_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetR2",420,G__G__Graf_102_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhimin",901,G__G__Graf_102_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhimax",903,G__G__Graf_102_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta",790,G__G__Graf_102_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoEdges",965,G__G__Graf_102_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintEllipse",1226,G__G__Graf_102_0_19, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - r1 d - 'Double_t' 0 - r2 "
"d - 'Double_t' 0 - phimin d - 'Double_t' 0 - phimax "
"d - 'Double_t' 0 - theta C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNoEdges",977,G__G__Graf_102_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' noEdges", "*TOGGLE* *GETTER=GetNoEdges", (void*) NULL, 1);
   G__memfunc_setup("SetPhimin",913,G__G__Graf_102_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' phi", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPhimax",915,G__G__Graf_102_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '360' phi", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetR1",431,G__G__Graf_102_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - r1", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetR2",432,G__G__Graf_102_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - r2", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTheta",802,G__G__Graf_102_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' theta", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetX1",437,G__G__Graf_102_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x1", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetY1",438,G__G__Graf_102_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y1", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_102_0_30, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEllipse::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_102_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEllipse::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_102_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEllipse::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_102_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEllipse::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_102_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_102_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEllipse::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_102_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEllipse::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_102_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEllipse::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_102_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEllipse::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEllipse", 928, G__G__Graf_102_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_102_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TEllipse), -1, 1, 1, 1, 1, 0, "u 'TEllipse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArc(void) {
   /* TArc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TArc));
   G__memfunc_setup("TArc",362,G__G__Graf_104_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TArc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArc",362,G__G__Graf_104_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TArc), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - radius d - 'Double_t' 0 '0' phimin "
"d - 'Double_t' 0 '360' phimax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArc",362,G__G__Graf_104_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TArc), -1, 0, 1, 1, 1, 0, "u 'TArc' - 11 - arc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - arc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawArc",676,G__G__Graf_104_0_5, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - radius d - 'Double_t' 0 '0' phimin "
"d - 'Double_t' 0 '360' phimax C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_104_0_7, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_104_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_104_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_104_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_104_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_104_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_104_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_104_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_104_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArc::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArc", 488, G__G__Graf_104_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_104_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TArc), -1, 1, 1, 1, 1, 0, "u 'TArc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLine(void) {
   /* TLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TLine));
   G__memfunc_setup("TLine",476,G__G__Graf_116_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLine",476,G__G__Graf_116_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLine",476,G__G__Graf_116_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 1, 1, 1, 0, "u 'TLine' - 11 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - line", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLine",790,G__G__Graf_116_0_6, 85, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLineNDC",1003,G__G__Graf_116_0_7, 85, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX1",425,G__G__Graf_116_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX2",426,G__G__Graf_116_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY1",426,G__G__Graf_116_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY2",427,G__G__Graf_116_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHorizontal",1254,G__G__Graf_116_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVertical",1014,G__G__Graf_116_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintLine",900,G__G__Graf_116_0_17, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintLineNDC",1113,G__G__Graf_116_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - u1 d - 'Double_t' 0 - v1 "
"d - 'Double_t' 0 - u2 d - 'Double_t' 0 - v2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHorizontal",1366,G__G__Graf_116_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' set", "*TOGGLE* *GETTER=IsHorizontal", (void*) NULL, 0);
   G__memfunc_setup("SetVertical",1126,G__G__Graf_116_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' set", "*TOGGLE* *GETTER=IsVertical", (void*) NULL, 0);
   G__memfunc_setup("SetX1",437,G__G__Graf_116_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetX2",438,G__G__Graf_116_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY1",438,G__G__Graf_116_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY2",439,G__G__Graf_116_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_116_0_27, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_116_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_116_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_116_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_116_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_116_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_116_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_116_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_116_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLine", 602, G__G__Graf_116_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_116_0_40, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 1, 1, 1, 1, 0, "u 'TLine' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrow(void) {
   /* TArrow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TArrow));
   G__memfunc_setup("TArrow",607,G__G__Graf_118_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TArrow), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrow",607,G__G__Graf_118_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TArrow), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"f - 'Float_t' 0 '0.05' arrowsize C - 'Option_t' 10 '\">\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrow",607,G__G__Graf_118_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TArrow), -1, 0, 1, 1, 1, 0, "u 'TArrow' - 11 - arrow", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - arrow", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawArrow",921,G__G__Graf_118_0_6, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"f - 'Float_t' 0 '0' arrowsize C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAngle",775,G__G__Graf_118_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArrowSize",1222,G__G__Graf_118_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintArrow",1031,G__G__Graf_118_0_11, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"f - 'Float_t' 0 '0.05' arrowsize C - 'Option_t' 10 '\">\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAngle",787,G__G__Graf_118_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '60' angle", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetArrowSize",1234,G__G__Graf_118_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.05' arrowsize", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Graf_118_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\">\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultAngle",1496,G__G__Graf_118_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - Angle", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TArrow::SetDefaultAngle) ), 0);
   G__memfunc_setup("SetDefaultArrowSize",1943,G__G__Graf_118_0_17, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - ArrowSize", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TArrow::SetDefaultArrowSize) ), 0);
   G__memfunc_setup("SetDefaultOption",1642,G__G__Graf_118_0_18, 121, -1, -1, 0, 1, 3, 1, 0, "C - 'Option_t' 10 - Option", (char*)NULL, (void*) G__func2void( (void (*)(Option_t*))(&TArrow::SetDefaultOption) ), 0);
   G__memfunc_setup("GetDefaultAngle",1484,G__G__Graf_118_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TArrow::GetDefaultAngle) ), 0);
   G__memfunc_setup("GetDefaultArrowSize",1931,G__G__Graf_118_0_20, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TArrow::GetDefaultArrowSize) ), 0);
   G__memfunc_setup("GetDefaultOption",1630,G__G__Graf_118_0_21, 67, -1, G__defined_typename("Option_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Option_t* (*)())(&TArrow::GetDefaultOption) ), 0);
   G__memfunc_setup("Class",502,G__G__Graf_118_0_22, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_118_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_118_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_118_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_118_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_118_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_118_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_118_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_118_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrow::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrow", 733, G__G__Graf_118_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_118_0_35, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TArrow), -1, 1, 1, 1, 1, 0, "u 'TArrow' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAttImage(void) {
   /* TAttImage */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TAttImage));
   G__memfunc_setup("TAttImage",864,G__G__Graf_119_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TAttImage), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAttImage",864,G__G__Graf_119_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TAttImage), -1, 0, 3, 1, 1, 0, 
"i 'TAttImage::EImageQuality' - 0 - lquality h - 'UInt_t' 0 - lcompression "
"g - 'Bool_t' 0 - constRatio", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Graf_119_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TAttImage' - 1 - attline", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConstRatio",1318,G__G__Graf_119_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImageCompression",1941,G__G__Graf_119_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImageQuality",1516,G__G__Graf_119_0_6, 105, G__get_linked_tagnum(&G__G__GrafLN_TAttImagecLcLEImageQuality), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPalette",1007,G__G__Graf_119_0_7, 117, G__get_linked_tagnum(&G__G__GrafLN_TImagePalette), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAttImage",1295,G__G__Graf_119_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveImageAttributes",1945,G__G__Graf_119_0_9, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"i 'TAttImage::EImageQuality' - 0 'kImgDefault' qualdef h - 'UInt_t' 0 '0' comprdef "
"g - 'Bool_t' 0 'kTRUE' constRatiodef", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConstRatio",1330,G__G__Graf_119_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' constRatio", "*TOGGLE*", (void*) NULL, 1);
   G__memfunc_setup("SetPaletteEnabled",1702,G__G__Graf_119_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImageCompression",1953,G__G__Graf_119_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - lcompression", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetImageQuality",1528,G__G__Graf_119_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TAttImage::EImageQuality' - 0 - lquality", "*SUBMENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPalette",1019,G__G__Graf_119_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TImagePalette' - 10 - palette", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPaletteEditor",1860,G__G__Graf_119_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("EditorClosed",1217,G__G__Graf_119_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsPaletteEnabled",1590,G__G__Graf_119_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_119_0_18, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttImage::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_119_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttImage::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_119_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttImage::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_119_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttImage::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Graf_119_0_22, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Graf_119_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Graf_119_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_119_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_119_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttImage::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_119_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttImage::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_119_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttImage::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_119_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttImage::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TAttImage", 864, G__G__Graf_119_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TAttImage), -1, 0, 1, 1, 1, 0, "u 'TAttImage' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TAttImage", 990, G__G__Graf_119_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_119_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TAttImage), -1, 1, 1, 1, 1, 0, "u 'TAttImage' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPaletteEditor(void) {
   /* TPaletteEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaletteEditor));
   G__memfunc_setup("TPaletteEditor",1418,G__G__Graf_120_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaletteEditor), -1, 0, 3, 1, 1, 0, 
"U 'TAttImage' - 0 - attImage h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,G__G__Graf_120_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_120_0_3, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPaletteEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_120_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaletteEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_120_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPaletteEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_120_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPaletteEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Graf_120_0_7, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Graf_120_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Graf_120_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_120_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_120_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaletteEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_120_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaletteEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_120_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaletteEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_120_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaletteEditor::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPaletteEditor", 1418, G__G__Graf_120_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TPaletteEditor), -1, 0, 1, 1, 1, 0, "u 'TPaletteEditor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPaletteEditor", 1544, G__G__Graf_120_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_120_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPaletteEditor), -1, 1, 1, 1, 1, 0, "u 'TPaletteEditor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTImagePalette(void) {
   /* TImagePalette */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TImagePalette));
   G__memfunc_setup("TImagePalette",1286,G__G__Graf_121_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TImagePalette), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TImagePalette",1286,G__G__Graf_121_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TImagePalette), -1, 0, 1, 1, 1, 0, "u 'TImagePalette' - 11 - palette", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TImagePalette",1286,G__G__Graf_121_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TImagePalette), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - numPoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TImagePalette",1286,G__G__Graf_121_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TImagePalette), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ncolors I - 'Int_t' 0 - colors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindColor",896,G__G__Graf_121_0_5, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"r - 'UShort_t' 0 - r r - 'UShort_t' 0 - g "
"r - 'UShort_t' 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRootColors",1334,G__G__Graf_121_0_6, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Graf_121_0_7, 117, G__get_linked_tagnum(&G__G__GrafLN_TImagePalette), -1, 1, 1, 1, 1, 0, "u 'TImagePalette' - 11 - palette", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_121_0_8, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TImagePalette::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_121_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImagePalette::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_121_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TImagePalette::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_121_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TImagePalette::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_121_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_121_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImagePalette::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_121_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TImagePalette::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_121_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImagePalette::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_121_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TImagePalette::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TImagePalette", 1412, G__G__Graf_121_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBox(void) {
   /* TBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TBox));
   G__memfunc_setup("TBox",381,G__G__Graf_123_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBox",381,G__G__Graf_123_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBox",381,G__G__Graf_123_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 0, 1, 1, 1, 0, "u 'TBox' - 11 - box", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Graf_123_0_4, 117, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 1, 1, 1, 1, 0, "u 'TBox' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - box", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBox",695,G__G__Graf_123_0_8, 85, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsBeingResized",1399,G__G__Graf_123_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX1",425,G__G__Graf_123_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX2",426,G__G__Graf_123_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY1",426,G__G__Graf_123_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY2",427,G__G__Graf_123_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideToolTip",1093,G__G__Graf_123_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,G__G__Graf_123_0_16, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintBox",805,G__G__Graf_123_0_19, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetX1",437,G__G__Graf_123_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetX2",438,G__G__Graf_123_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY1",438,G__G__Graf_123_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY2",439,G__G__Graf_123_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetToolTipText",1436,G__G__Graf_123_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text l - 'Long_t' 0 '1000' delayms", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_123_0_27, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_123_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_123_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_123_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_123_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_123_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_123_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_123_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_123_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBox", 507, G__G__Graf_123_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCrown(void) {
   /* TCrown */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TCrown));
   G__memfunc_setup("TCrown",605,G__G__Graf_125_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TCrown), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCrown",605,G__G__Graf_125_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TCrown), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - radin d - 'Double_t' 0 - radout "
"d - 'Double_t' 0 '0' phimin d - 'Double_t' 0 '360' phimax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCrown",605,G__G__Graf_125_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TCrown), -1, 0, 1, 1, 1, 0, "u 'TCrown' - 11 - crown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - crown", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCrown",919,G__G__Graf_125_0_6, 121, -1, -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - radin d - 'Double_t' 0 - radout "
"d - 'Double_t' 0 '0' phimin d - 'Double_t' 0 '360' phimax "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_125_0_10, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCrown::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_125_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCrown::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_125_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCrown::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_125_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCrown::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_125_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_125_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCrown::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_125_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCrown::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_125_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCrown::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_125_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCrown::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCrown", 731, G__G__Graf_125_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_125_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TCrown), -1, 1, 1, 1, 1, 0, "u 'TCrown' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPolyLine(void) {
   /* TPolyLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPolyLine));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TPolyLine), -1, 1, 1, 1, 2, 0, "u 'TPolyLine' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyLine",896,G__G__Graf_127_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPolyLine), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyLine",896,G__G__Graf_127_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPolyLine), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyLine",896,G__G__Graf_127_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TPolyLine), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyLine",896,G__G__Graf_127_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TPolyLine), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyLine",896,G__G__Graf_127_0_6, 105, G__get_linked_tagnum(&G__G__GrafLN_TPolyLine), -1, 0, 1, 1, 1, 0, "u 'TPolyLine' - 11 - polyline", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - polyline", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyLine",1210,G__G__Graf_127_0_10, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLastPoint",1214,G__G__Graf_127_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,G__G__Graf_127_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Graf_127_0_14, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Graf_127_0_15, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Graf_127_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPolyLine",1320,G__G__Graf_127_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPolyLineNDC",1533,G__G__Graf_127_0_21, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNDC",513,G__G__Graf_127_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' isNDC", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNextPoint",1237,G__G__Graf_127_0_25, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Graf_127_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,G__G__Graf_127_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - point d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPolyLine",1112,G__G__Graf_127_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPolyLine",1112,G__G__Graf_127_0_29, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPolyLine",1112,G__G__Graf_127_0_30, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y3 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__G__Graf_127_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_127_0_32, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPolyLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_127_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_127_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPolyLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_127_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPolyLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_127_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_127_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_127_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_127_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_127_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPolyLine", 1022, G__G__Graf_127_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCurlyLine(void) {
   /* TCurlyLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine));
   G__memfunc_setup("TCurlyLine",1003,G__G__Graf_129_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCurlyLine",1003,G__G__Graf_129_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"d - 'Double_t' 0 '.02' wl d - 'Double_t' 0 '.01' amp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,G__G__Graf_129_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurly",815,G__G__Graf_129_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaveLength",1301,G__G__Graf_129_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAmplitude",1221,G__G__Graf_129_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStartX",902,G__G__Graf_129_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndX",655,G__G__Graf_129_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStartY",903,G__G__Graf_129_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndY",656,G__G__Graf_129_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurly",827,G__G__Graf_129_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetWavy",723,G__G__Graf_129_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetWaveLength",1313,G__G__Graf_129_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - WaveLength", "*MENU* *ARGS={WaveLength=>fWaveLength}", (void*) NULL, 1);
   G__memfunc_setup("SetAmplitude",1233,G__G__Graf_129_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", "*MENU* *ARGS={x=>fAmplitude}", (void*) NULL, 1);
   G__memfunc_setup("SetStartPoint",1348,G__G__Graf_129_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEndPoint",1101,G__G__Graf_129_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultWaveLength",2022,G__G__Graf_129_0_20, 121, -1, -1, 0, 1, 3, 1, 0, "d - 'Double_t' 0 - WaveLength", (char*)NULL, (void*) G__func2void( (void (*)(Double_t))(&TCurlyLine::SetDefaultWaveLength) ), 0);
   G__memfunc_setup("SetDefaultAmplitude",1942,G__G__Graf_129_0_21, 121, -1, -1, 0, 1, 3, 1, 0, "d - 'Double_t' 0 - Amplitude", (char*)NULL, (void*) G__func2void( (void (*)(Double_t))(&TCurlyLine::SetDefaultAmplitude) ), 0);
   G__memfunc_setup("SetDefaultIsCurly",1724,G__G__Graf_129_0_22, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - IsCurly", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TCurlyLine::SetDefaultIsCurly) ), 0);
   G__memfunc_setup("GetDefaultWaveLength",2010,G__G__Graf_129_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TCurlyLine::GetDefaultWaveLength) ), 0);
   G__memfunc_setup("GetDefaultAmplitude",1930,G__G__Graf_129_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TCurlyLine::GetDefaultAmplitude) ), 0);
   G__memfunc_setup("GetDefaultIsCurly",1712,G__G__Graf_129_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TCurlyLine::GetDefaultIsCurly) ), 0);
   G__memfunc_setup("Class",502,G__G__Graf_129_0_26, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCurlyLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_129_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_129_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCurlyLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_129_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCurlyLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_129_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_129_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_129_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_129_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_129_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyLine::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TCurlyLine", 1003, G__G__Graf_129_0_38, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TCurlyLine), -1, 0, 1, 1, 1, 0, "u 'TCurlyLine' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCurlyLine", 1129, G__G__Graf_129_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCurlyArc(void) {
   /* TCurlyArc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc));
   G__memfunc_setup("TCurlyArc",889,G__G__Graf_131_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCurlyArc",889,G__G__Graf_131_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - rad d - 'Double_t' 0 - phimin "
"d - 'Double_t' 0 - phimax d - 'Double_t' 0 '.02' wl "
"d - 'Double_t' 0 '.01' amp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRadius",904,G__G__Graf_131_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhimin",901,G__G__Graf_131_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhimax",903,G__G__Graf_131_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCenter",909,G__G__Graf_131_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1", "*MENU* *ARGS={x1=>fX1,y1=>fY1}", (void*) NULL, 1);
   G__memfunc_setup("SetRadius",916,G__G__Graf_131_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - radius", "*MENU* *ARGS={radius=>fR1}", (void*) NULL, 1);
   G__memfunc_setup("SetPhimin",913,G__G__Graf_131_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phimin", "*MENU* *ARGS={phimin=>fPhimin}", (void*) NULL, 1);
   G__memfunc_setup("SetPhimax",915,G__G__Graf_131_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phimax", "*MENU* *ARGS={phimax=>fPhimax}", (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultWaveLength",2022,G__G__Graf_131_0_14, 121, -1, -1, 0, 1, 3, 1, 0, "d - 'Double_t' 0 - WaveLength", (char*)NULL, (void*) G__func2void( (void (*)(Double_t))(&TCurlyArc::SetDefaultWaveLength) ), 0);
   G__memfunc_setup("SetDefaultAmplitude",1942,G__G__Graf_131_0_15, 121, -1, -1, 0, 1, 3, 1, 0, "d - 'Double_t' 0 - Amplitude", (char*)NULL, (void*) G__func2void( (void (*)(Double_t))(&TCurlyArc::SetDefaultAmplitude) ), 0);
   G__memfunc_setup("SetDefaultIsCurly",1724,G__G__Graf_131_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - IsCurly", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TCurlyArc::SetDefaultIsCurly) ), 0);
   G__memfunc_setup("GetDefaultWaveLength",2010,G__G__Graf_131_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TCurlyArc::GetDefaultWaveLength) ), 0);
   G__memfunc_setup("GetDefaultAmplitude",1930,G__G__Graf_131_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TCurlyArc::GetDefaultAmplitude) ), 0);
   G__memfunc_setup("GetDefaultIsCurly",1712,G__G__Graf_131_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TCurlyArc::GetDefaultIsCurly) ), 0);
   G__memfunc_setup("Class",502,G__G__Graf_131_0_20, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCurlyArc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_131_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_131_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCurlyArc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_131_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCurlyArc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_131_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_131_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_131_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyArc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_131_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_131_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyArc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TCurlyArc", 889, G__G__Graf_131_0_32, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TCurlyArc), -1, 0, 1, 1, 1, 0, "u 'TCurlyArc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCurlyArc", 1015, G__G__Graf_131_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCutG(void) {
   /* TCutG */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TCutG));
   G__memfunc_setup("TCutG",455,G__G__Graf_146_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TCutG), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCutG",455,G__G__Graf_146_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TCutG), -1, 0, 1, 1, 1, 0, "u 'TCutG' - 11 - cutg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCutG",455,G__G__Graf_146_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TCutG), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCutG",455,G__G__Graf_146_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TCutG), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n "
"F - 'Float_t' 10 - x F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCutG",455,G__G__Graf_146_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TCutG), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n "
"D - 'Double_t' 10 - x D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Area",377,G__G__Graf_146_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Center",609,G__G__Graf_146_0_7, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - cx d - 'Double_t' 1 - cy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectX",975,G__G__Graf_146_0_8, 85, G__get_linked_tagnum(&G__G__GrafLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectY",976,G__G__Graf_146_0_9, 85, G__get_linked_tagnum(&G__G__GrafLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVarX",673,G__G__Graf_146_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVarY",674,G__G__Graf_146_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegralHist",1230,G__G__Graf_146_0_12, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH2' - 0 - h C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObjectX",987,G__G__Graf_146_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObjectY",988,G__G__Graf_146_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVarX",685,G__G__Graf_146_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - varx", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetVarY",686,G__G__Graf_146_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - vary", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_146_0_18, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCutG::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_146_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCutG::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_146_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCutG::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_146_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCutG::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_146_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_146_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCutG::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_146_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCutG::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_146_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCutG::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_146_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCutG::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCutG", 581, G__G__Graf_146_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_146_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TCutG), -1, 1, 1, 1, 1, 0, "u 'TCutG' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPave(void) {
   /* TPave */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPave));
   G__memfunc_setup("TPave",480,G__G__Graf_147_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPave), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPave",480,G__G__Graf_147_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPave), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i - 'Int_t' 0 '4' bordersize C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPave",480,G__G__Graf_147_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPave), -1, 0, 1, 1, 1, 0, "u 'TPave' - 11 - pave", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - pave", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConvertNDCtoPad",1454,G__G__Graf_147_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPave",794,G__G__Graf_147_0_8, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i - 'Int_t' 0 '4' bordersize C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBorderSize",1305,G__G__Graf_147_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCornerRadius",1521,G__G__Graf_147_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__Graf_147_0_12, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShadowColor",1413,G__G__Graf_147_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX1NDC",638,G__G__Graf_147_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX2NDC",639,G__G__Graf_147_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY1NDC",639,G__G__Graf_147_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY2NDC",640,G__G__Graf_147_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPave",904,G__G__Graf_147_0_23, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i - 'Int_t' 0 '4' bordersize C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPaveArc",1182,G__G__Graf_147_0_24, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i - 'Int_t' 0 '4' bordersize C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBorderSize",1317,G__G__Graf_147_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '4' bordersize", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetCornerRadius",1533,G__G__Graf_147_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.2' rad", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetName",685,G__G__Graf_147_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Graf_147_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShadowColor",1425,G__G__Graf_147_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - color", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetX1NDC",650,G__G__Graf_147_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetX2NDC",651,G__G__Graf_147_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY1NDC",651,G__G__Graf_147_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY2NDC",652,G__G__Graf_147_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_147_0_36, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPave::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_147_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPave::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_147_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPave::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_147_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPave::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_147_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_147_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPave::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_147_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPave::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_147_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPave::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_147_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPave::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPave", 606, G__G__Graf_147_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_147_0_49, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPave), -1, 1, 1, 1, 1, 0, "u 'TPave' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTText(void) {
   /* TText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TText));
   G__memfunc_setup("TText",505,G__G__Graf_150_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TText",505,G__G__Graf_150_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TText",505,G__G__Graf_150_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 1, 1, 1, 0, "u 'TText' - 11 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,G__G__Graf_150_0_6, 85, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawTextNDC",1032,G__G__Graf_150_0_7, 85, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetControlBox",1322,G__G__Graf_150_0_9, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"d - 'Double_t' 0 - theta I - 'Int_t' 0 - cBoxX "
"I - 'Int_t' 0 - cBoxY", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,G__G__Graf_150_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoundingBox",1407,G__G__Graf_150_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h "
"g - 'Bool_t' 0 'kFALSE' angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextAscentDescent",2025,G__G__Graf_150_0_12, 121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 1 - a h - 'UInt_t' 1 - d "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextExtent",1341,G__G__Graf_150_0_13, 121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextAdvance",1399,G__G__Graf_150_0_14, 121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 1 - a C - - 10 - text "
"g - 'Bool_t' 10 'kTRUE' kern", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetY",377,G__G__Graf_150_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintControlBox",1542,G__G__Graf_150_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"d - 'Double_t' 0 - theta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintText",929,G__G__Graf_150_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintTextNDC",1142,G__G__Graf_150_0_20, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - u d - 'Double_t' 0 - v "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNDC",513,G__G__Graf_150_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' isNDC", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Graf_150_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", "*MENU* *ARGS={x=>fX,y=>fY,text=>fTitle}", (void*) NULL, 1);
   G__memfunc_setup("SetX",388,G__G__Graf_150_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetY",389,G__G__Graf_150_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_150_0_27, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_150_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_150_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_150_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_150_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_150_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_150_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_150_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_150_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TText::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TText", 631, G__G__Graf_150_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_150_0_40, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 1, 1, 1, 1, 0, "u 'TText' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPaveText(void) {
   /* TPaveText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveText));
   G__memfunc_setup("TPaveText",901,G__G__Graf_152_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPaveText",901,G__G__Graf_152_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveText), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPaveText",901,G__G__Graf_152_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveText), -1, 0, 1, 1, 1, 0, "u 'TPaveText' - 11 - pavetext", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Graf_152_0_4, 117, G__get_linked_tagnum(&G__G__GrafLN_TPaveText), -1, 1, 1, 1, 1, 0, "u 'TPaveText' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBox",562,G__G__Graf_152_0_5, 85, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLine",657,G__G__Graf_152_0_6, 85, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '0' x1 d - 'Double_t' 0 '0' y1 "
"d - 'Double_t' 0 '0' x2 d - 'Double_t' 0 '0' y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddText",686,G__G__Graf_152_0_7, 85, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddText",686,G__G__Graf_152_0_8, 85, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DeleteText",1016,G__G__Graf_152_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFile",782,G__G__Graf_152_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EditText",811,G__G__Graf_152_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetLabel",768,G__G__Graf_152_0_14, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLine",680,G__G__Graf_152_0_15, 85, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineWith",1092,G__G__Graf_152_0_16, 85, G__get_linked_tagnum(&G__G__GrafLN_TText), -1, 0, 1, 1, 1, 8, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfLines",1388,G__G__Graf_152_0_17, 85, G__get_linked_tagnum(&G__G__GrafLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMargin",894,G__G__Graf_152_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Graf_152_0_19, 85, G__get_linked_tagnum(&G__G__GrafLN_TObject), -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - ymouse d - 'Double_t' 1 - yobj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__Graf_152_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertLine",1021,G__G__Graf_152_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("InsertText",1050,G__G__Graf_152_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPrimitives",1576,G__G__Graf_152_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFile",764,G__G__Graf_152_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
"i - 'Int_t' 0 '50' nlines i - 'Int_t' 0 '0' fromline", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SaveLines",906,G__G__Graf_152_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAllWith",993,G__G__Graf_152_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - text C - 'Option_t' 10 - option "
"d - 'Double_t' 0 - value", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetLabel",780,G__G__Graf_152_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMargin",906,G__G__Graf_152_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.05' margin", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_152_0_33, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPaveText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_152_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_152_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPaveText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_152_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPaveText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_152_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_152_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_152_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_152_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_152_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveText::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPaveText", 1027, G__G__Graf_152_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDiamond(void) {
   /* TDiamond */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TDiamond));
   G__memfunc_setup("TDiamond",784,G__G__Graf_153_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TDiamond), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDiamond",784,G__G__Graf_153_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TDiamond), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDiamond",784,G__G__Graf_153_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TDiamond), -1, 0, 1, 1, 1, 0, "u 'TDiamond' - 11 - diamond", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_153_0_9, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDiamond::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_153_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDiamond::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_153_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDiamond::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_153_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDiamond::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_153_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_153_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDiamond::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_153_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDiamond::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_153_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDiamond::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_153_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDiamond::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDiamond", 910, G__G__Graf_153_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_153_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TDiamond), -1, 1, 1, 1, 1, 0, "u 'TDiamond' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTWbox(void) {
   /* TWbox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TWbox));
   G__memfunc_setup("TWbox",500,G__G__Graf_157_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TWbox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TWbox",500,G__G__Graf_157_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TWbox), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"s - 'Color_t' 0 '18' color s - 'Short_t' 0 '5' bordersize "
"s - 'Short_t' 0 '1' bordermode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TWbox",500,G__G__Graf_157_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TWbox), -1, 0, 1, 1, 1, 0, "u 'TWbox' - 11 - wbox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - wbox", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawWbox",814,G__G__Graf_157_0_6, 121, -1, -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"s - 'Color_t' 0 '33' color s - 'Short_t' 0 '5' bordersize "
"s - 'Short_t' 0 '-1' bordermode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBorderMode",1283,G__G__Graf_157_0_8, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBorderSize",1305,G__G__Graf_157_0_9, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDarkColor",1185,G__G__Graf_157_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLightColor",1303,G__G__Graf_157_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintFrame",999,G__G__Graf_157_0_13, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"s - 'Color_t' 0 - color s - 'Short_t' 0 - bordersize "
"s - 'Short_t' 0 - bordermode g - 'Bool_t' 0 - tops", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintWbox",924,G__G__Graf_157_0_14, 121, -1, -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"s - 'Color_t' 0 '33' color s - 'Short_t' 0 '5' bordersize "
"s - 'Short_t' 0 '-1' bordermode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBorderMode",1295,G__G__Graf_157_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - bordermode", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetBorderSize",1317,G__G__Graf_157_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - bordersize", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_157_0_18, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TWbox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_157_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWbox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_157_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TWbox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_157_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TWbox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_157_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_157_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWbox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_157_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWbox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_157_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWbox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_157_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWbox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TWbox", 626, G__G__Graf_157_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_157_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TWbox), -1, 1, 1, 1, 1, 0, "u 'TWbox' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFrame(void) {
   /* TFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TFrame));
   G__memfunc_setup("TFrame",575,G__G__Graf_158_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFrame",575,G__G__Graf_158_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TFrame), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFrame",575,G__G__Graf_158_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TFrame), -1, 0, 1, 1, 1, 0, "u 'TFrame' - 11 - frame", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - frame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pop",303,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_158_0_11, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_158_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_158_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_158_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_158_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_158_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_158_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_158_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_158_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFrame", 701, G__G__Graf_158_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_158_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TFrame), -1, 1, 1, 1, 1, 0, "u 'TFrame' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGaxis(void) {
   /* TGaxis */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TGaxis));
   G__memfunc_setup("TGaxis",592,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GrafLN_TGaxis), -1, 0, 1, 1, 2, 0, "u 'TGaxis' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TGaxis), -1, 1, 1, 1, 2, 0, "u 'TGaxis' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGaxis",592,G__G__Graf_159_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TGaxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGaxis",592,G__G__Graf_159_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TGaxis), -1, 0, 9, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - wmin d - 'Double_t' 0 - wmax "
"i - 'Int_t' 0 '510' ndiv C - 'Option_t' 10 '\"\"' chopt "
"d - 'Double_t' 0 '0' gridlength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGaxis",592,G__G__Graf_159_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TGaxis), -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax "
"C - - 10 - funcname i - 'Int_t' 0 '510' ndiv "
"C - 'Option_t' 10 '\"\"' chopt d - 'Double_t' 0 '0' gridlength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustBinSize",1311,G__G__Graf_159_0_6, 121, -1, -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - A1 d - 'Double_t' 0 - A2 "
"i - 'Int_t' 0 - nold d - 'Double_t' 1 - BinLow "
"d - 'Double_t' 1 - BinHigh i - 'Int_t' 1 - nbins "
"d - 'Double_t' 1 - BinWidth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CenterLabels",1204,G__G__Graf_159_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' center", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CenterTitle",1123,G__G__Graf_159_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' center", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawAxis",803,G__G__Graf_159_0_9, 121, -1, -1, 0, 9, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - wmin d - 'Double_t' 0 - wmax "
"i - 'Int_t' 0 '510' ndiv C - 'Option_t' 10 '\"\"' chopt "
"d - 'Double_t' 0 '0' gridlength", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGridLength",1288,G__G__Graf_159_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunction",1126,G__G__Graf_159_0_11, 85, G__get_linked_tagnum(&G__G__GrafLN_TF1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelColor",1279,G__G__Graf_159_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelFont",1175,G__G__Graf_159_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelOffset",1383,G__G__Graf_159_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelSize",1179,G__G__Graf_159_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitleOffset",1417,G__G__Graf_159_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitleSize",1213,G__G__Graf_159_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,G__G__Graf_159_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxDigits",1194,G__G__Graf_159_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TGaxis::GetMaxDigits) ), 0);
   G__memfunc_setup("GetNdiv",689,G__G__Graf_159_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWmin",699,G__G__Graf_159_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWmax",701,G__G__Graf_159_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTickSize",1094,G__G__Graf_159_0_25, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportAxisAttributes",2103,G__G__Graf_159_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TAxis' - 0 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsLimits",1221,G__G__Graf_159_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - label i - 'Int_t' 1 - first "
"i - 'Int_t' 1 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintAxis",913,G__G__Graf_159_0_29, 121, -1, -1, 0, 10, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax "
"d - 'Double_t' 1 - wmin d - 'Double_t' 1 - wmax "
"i - 'Int_t' 1 - ndiv C - 'Option_t' 10 '\"\"' chopt "
"d - 'Double_t' 0 '0' gridlength g - 'Bool_t' 0 'kFALSE' drawGridOnly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rotate",623,G__G__Graf_159_0_30, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - X d - 'Double_t' 0 - Y "
"d - 'Double_t' 0 - CFI d - 'Double_t' 0 - SFI "
"d - 'Double_t' 0 - XT d - 'Double_t' 0 - YT "
"d - 'Double_t' 1 - U d - 'Double_t' 1 - V", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFunction",1138,G__G__Graf_159_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' funcname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOption",933,G__G__Graf_159_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelColor",1291,G__G__Graf_159_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - labelcolor", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLabelFont",1187,G__G__Graf_159_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - labelfont", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLabelOffset",1395,G__G__Graf_159_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - labeloffset", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLabelSize",1191,G__G__Graf_159_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - labelsize", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMaxDigits",1206,G__G__Graf_159_0_38, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '5' maxd", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TGaxis::SetMaxDigits) ), 0);
   G__memfunc_setup("SetName",685,G__G__Graf_159_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNdivisions",1362,G__G__Graf_159_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndiv", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMoreLogLabels",1588,G__G__Graf_159_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' more", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNoExponent",1338,G__G__Graf_159_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' noExponent", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetDecimals",1102,G__G__Graf_159_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' dot", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTickSize",1106,G__G__Graf_159_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - ticksize", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetGridLength",1300,G__G__Graf_159_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - gridlength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeFormat",1316,G__G__Graf_159_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - tformat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeOffset",1314,G__G__Graf_159_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - toffset C - 'Option_t' 10 '\"local\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitle",814,G__G__Graf_159_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' title", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTitleOffset",1429,G__G__Graf_159_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' titleoffset", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetTitleSize",1225,G__G__Graf_159_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - titlesize", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetTitleFont",1221,G__G__Graf_159_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - titlefont", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetTitleColor",1325,G__G__Graf_159_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - titlecolor", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetWmin",711,G__G__Graf_159_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - wmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWmax",713,G__G__Graf_159_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - wmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_159_0_55, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGaxis::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_159_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGaxis::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_159_0_57, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGaxis::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_159_0_58, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGaxis::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_159_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_159_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGaxis::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_159_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGaxis::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_159_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGaxis::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_159_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGaxis::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGaxis", 718, G__G__Graf_159_0_67, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphPolargram(void) {
   /* TGraphPolargram */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram));
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - 'Option_t' 10 '\"\"' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintRadialDivisions",2049,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - drawaxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintPolarDivisions",1970,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - noLabels", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReduceFraction",1422,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - Num i - 'Int_t' 0 - Denom "
"i - 'Int_t' 1 - rnum i - 'Int_t' 1 - rden", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindAlign",876,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTextAngle",1293,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphPolargram",1515,G__G__Graf_160_0_8, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - tmin "
"d - 'Double_t' 0 - tmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphPolargram",1515,G__G__Graf_160_0_9, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolarColorLabel",1789,G__G__Graf_160_0_10, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRadialColorLabel",1868,G__G__Graf_160_0_11, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAngle",775,G__G__Graf_160_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolarLabelSize",1689,G__G__Graf_160_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolarOffset",1413,G__G__Graf_160_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRadialLabelSize",1768,G__G__Graf_160_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRadialOffset",1492,G__G__Graf_160_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRMin",662,G__G__Graf_160_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRMax",664,G__G__Graf_160_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTickpolarSize",1636,G__G__Graf_160_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTMin",664,G__G__Graf_160_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTMax",666,G__G__Graf_160_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolarLabelFont",1685,G__G__Graf_160_0_22, 115, -1, G__defined_typename("Font_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRadialLabelFont",1764,G__G__Graf_160_0_23, 115, -1, G__defined_typename("Font_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdivPolar",1199,G__G__Graf_160_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdivRadial",1278,G__G__Graf_160_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDegree",776,G__G__Graf_160_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRadian",779,G__G__Graf_160_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsGrad",570,G__G__Graf_160_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeRangePolar",1585,G__G__Graf_160_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - tmin d - 'Double_t' 0 - tmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintCircle",1102,G__G__Graf_160_0_33, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - r d - 'Double_t' 0 - phimin "
"d - 'Double_t' 0 - phimax d - 'Double_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxisAngle",1192,G__G__Graf_160_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' angle", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetNdivPolar",1211,G__G__Graf_160_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '508' Ndiv", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetNdivRadial",1290,G__G__Graf_160_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '508' Ndiv", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPolarLabel",1290,G__G__Graf_160_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - div u 'TString' - 11 - label", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPolarLabelSize",1701,G__G__Graf_160_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.04' angularsize", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPolarLabelColor",1801,G__G__Graf_160_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' tcolorangular", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPolarLabelFont",1697,G__G__Graf_160_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 '62' tfontangular", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPolarOffset",1425,G__G__Graf_160_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.04' PolarOffset", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRadialOffset",1504,G__G__Graf_160_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.025' RadialOffset", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRadialLabelSize",1780,G__G__Graf_160_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.035' radialsize", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRadialLabelColor",1880,G__G__Graf_160_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' tcolorradial", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRadialLabelFont",1776,G__G__Graf_160_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 '62' tfontradial", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRangePolar",1303,G__G__Graf_160_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - tmin d - 'Double_t' 0 - tmax", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRangeRadial",1382,G__G__Graf_160_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetTickpolarSize",1648,G__G__Graf_160_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.02' tickpolarsize", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetToDegree",1083,G__G__Graf_160_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetToGrad",877,G__G__Graf_160_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetToRadian",1086,G__G__Graf_160_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetTwoPi",799,G__G__Graf_160_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_160_0_53, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphPolargram::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_160_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphPolargram::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_160_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphPolargram::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_160_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphPolargram::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_160_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_160_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphPolargram::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_160_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphPolargram::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_160_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphPolargram::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_160_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphPolargram::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGraphPolargram", 1515, G__G__Graf_160_0_65, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram), -1, 0, 1, 1, 1, 0, "u 'TGraphPolargram' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGraphPolargram", 1641, G__G__Graf_160_0_66, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_160_0_67, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram), -1, 1, 1, 1, 1, 0, "u 'TGraphPolargram' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphPolar(void) {
   /* TGraphPolar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar));
   G__memfunc_setup("TGraphPolar",1092,G__G__Graf_163_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphPolar",1092,G__G__Graf_163_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 '0' x "
"D - 'Double_t' 10 '0' y D - 'Double_t' 10 '0' ex "
"D - 'Double_t' 10 '0' ey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolargram",1221,G__G__Graf_163_0_3, 85, G__get_linked_tagnum(&G__G__GrafLN_TGraphPolargram), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOptionAxis",1326,G__G__Graf_163_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxRadial",1183,G__G__Graf_163_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '1' maximum", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMinRadial",1181,G__G__Graf_163_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' minimum", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMaximum",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '1' maximum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' minimum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxPolar",1104,G__G__Graf_163_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '6.28318530717958623' maximum", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMinPolar",1102,G__G__Graf_163_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' minimum", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetOptionAxis",1338,G__G__Graf_163_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPolargram",1233,G__G__Graf_163_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGraphPolargram' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXpol",707,G__G__Graf_163_0_14, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYpol",708,G__G__Graf_163_0_15, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_163_0_16, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphPolar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_163_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphPolar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_163_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphPolar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_163_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphPolar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_163_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_163_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphPolar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_163_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphPolar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_163_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphPolar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_163_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphPolar::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGraphPolar", 1092, G__G__Graf_163_0_28, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar), -1, 0, 1, 1, 1, 0, "u 'TGraphPolar' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGraphPolar", 1218, G__G__Graf_163_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_163_0_30, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TGraphPolar), -1, 1, 1, 1, 1, 0, "u 'TGraphPolar' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphQQ(void) {
   /* TGraphQQ */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ));
   G__memfunc_setup("Quartiles",954,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeQuantiles",1332,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeFunctionQuantiles",2170,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphQQ",744,G__G__Graf_164_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphQQ",744,G__G__Graf_164_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphQQ",744,G__G__Graf_164_0_6, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"U 'TF1' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphQQ",744,G__G__Graf_164_0_7, 105, G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nx D - 'Double_t' 0 - x "
"i - 'Int_t' 0 - ny D - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFunction",1138,G__G__Graf_164_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TF1' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXq1",538,G__G__Graf_164_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXq2",539,G__G__Graf_164_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYq1",539,G__G__Graf_164_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYq2",540,G__G__Graf_164_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetF",358,G__G__Graf_164_0_13, 85, G__get_linked_tagnum(&G__G__GrafLN_TF1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_164_0_14, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphQQ::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_164_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphQQ::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_164_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphQQ::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_164_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphQQ::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_164_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_164_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphQQ::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_164_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphQQ::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_164_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphQQ::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_164_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphQQ::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGraphQQ", 744, G__G__Graf_164_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ), -1, 0, 1, 1, 1, 0, "u 'TGraphQQ' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGraphQQ", 870, G__G__Graf_164_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_164_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TGraphQQ), -1, 1, 1, 1, 1, 0, "u 'TGraphQQ' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTImage(void) {
   /* TImage */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TImage));
   G__memfunc_setup("TImage",567,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 1, 1, 2, 0, "C - - 10 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TImage",567,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TImage",567,G__G__Graf_186_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 1, 1, 1, 0, "u 'TImage' - 11 - img", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Graf_186_0_4, 117, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 1, 1, 1, 1, 0, "u 'TImage' - 11 - img", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TImage",567,G__G__Graf_186_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadImage",863,G__G__Graf_186_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - i 'TImage::EImageFileTypes' - 0 'TImage::kUnknown' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteImage",1006,G__G__Graf_186_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - i 'TImage::EImageFileTypes' - 0 'TImage::kUnknown' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Graf_186_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"D - 'Double_t' 10 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - U 'TImagePalette' - 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Graf_186_0_10, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TArrayD' - 11 - - h - 'UInt_t' 0 - - "
"U 'TImagePalette' - 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Graf_186_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - - h - 'UInt_t' 0 - - "
"U 'TImagePalette' - 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Graf_186_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Pixmap_t' 0 - - k - 'Pixmap_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FromPad",681,G__G__Graf_186_0_13, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TVirtualPad' - 0 - - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnZoom",616,G__G__Graf_186_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zoom",421,G__G__Graf_186_0_15, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Flip",395,G__G__Graf_186_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '180' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Gray",403,G__G__Graf_186_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsGray",591,G__G__Graf_186_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mirror",635,G__G__Graf_186_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scale",488,G__G__Graf_186_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Slice",496,G__G__Graf_186_0_21, 121, -1, -1, 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Tile",398,G__G__Graf_186_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Crop",404,G__G__Graf_186_0_23, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' - "
"h - 'UInt_t' 0 '0' - h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pad",277,G__G__Graf_186_0_24, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 '\"#FFFFFFFF\"' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Blur",405,G__G__Graf_186_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '3' - d - 'Double_t' 0 '3' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Vectorize",955,G__G__Graf_186_0_26, 68, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 '256' - h - 'UInt_t' 0 '4' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HSV",241,G__G__Graf_186_0_27, 121, -1, -1, 0, 9, 1, 1, 0, 
"h - 'UInt_t' 0 '0' - h - 'UInt_t' 0 '360' - "
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Gradient",814,G__G__Graf_186_0_28, 121, -1, -1, 0, 7, 1, 1, 0, 
"h - 'UInt_t' 0 '0' - C - - 10 '\"#FFFFFF #000000\"' - "
"C - - 10 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Graf_186_0_29, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TImage' - 10 - - C - - 10 '\"alphablend\"' - "
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Append",600,G__G__Graf_186_0_30, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TImage' - 10 - - C - - 10 '\"+\"' - "
"C - - 10 '\"#00000000\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Bevel",494,G__G__Graf_186_0_31, 121, -1, -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' - "
"h - 'UInt_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"C - - 10 '\"#ffdddddd\"' - C - - 10 '\"#ff555555\"' - "
"r - 'UShort_t' 0 '1' - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginPaint",993,G__G__Graf_186_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EndPaint",787,G__G__Graf_186_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLine",790,G__G__Graf_186_0_34, 121, -1, -1, 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawDashLine",1174,G__G__Graf_186_0_35, 121, -1, -1, 0, 8, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - C - - 10 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBox",695,G__G__Graf_186_0_36, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawRectangle",1315,G__G__Graf_186_0_37, 121, -1, -1, 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - h - 'UInt_t' 0 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRectangle",1308,G__G__Graf_186_0_38, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 '0' - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyLine",1210,G__G__Graf_186_0_39, 121, -1, -1, 0, 5, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' - "
"i 'TImage::ECoordMode' - 0 'kCoordModeOrigin' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PutPixel",827,G__G__Graf_186_0_40, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - - 10 '\"#000000\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PolyPoint",942,G__G__Graf_186_0_41, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"C - - 10 '\"#000000\"' - i 'TImage::ECoordMode' - 0 'kCoordModeOrigin' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSegments",1236,G__G__Graf_186_0_42, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'Segment_t' - 0 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,G__G__Graf_186_0_43, 121, -1, -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' - "
"C - - 10 '\"\"' - i - 'Int_t' 0 '12' - "
"C - - 10 '0' - C - - 10 '\"fixed\"' - "
"i 'TImage::EText3DType' - 0 'TImage::kPlain' - C - - 10 '0' - "
"f - 'Float_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,G__G__Graf_186_0_44, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TText' - 0 - - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillPolygon",1135,G__G__Graf_186_0_45, 121, -1, -1, 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"C - - 10 '\"#000000\"' - C - - 10 '0' - "
"h - 'UInt_t' 0 '16' - h - 'UInt_t' 0 '16' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillPolygon",1135,G__G__Graf_186_0_46, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"U 'TImage' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CropPolygon",1148,G__G__Graf_186_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFillArea",1166,G__G__Graf_186_0_48, 121, -1, -1, 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"C - - 10 '\"#000000\"' - C - - 10 '0' - "
"h - 'UInt_t' 0 '16' - h - 'UInt_t' 0 '16' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFillArea",1166,G__G__Graf_186_0_49, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"U 'TImage' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillSpans",908,G__G__Graf_186_0_50, 121, -1, -1, 0, 7, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"H - 'UInt_t' 0 - - C - - 10 '\"#000000\"' - "
"C - - 10 '0' - h - 'UInt_t' 0 '16' - "
"h - 'UInt_t' 0 '16' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillSpans",908,G__G__Graf_186_0_51, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"H - 'UInt_t' 0 - - U 'TImage' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CropSpans",921,G__G__Graf_186_0_52, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - - U 'TPoint' - 0 - - "
"H - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyArea",788,G__G__Graf_186_0_53, 121, -1, -1, 0, 9, 1, 1, 0, 
"U 'TImage' - 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '3' - "
"i 'TImage::EColorChan' - 0 'kAllChan' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCellArray",1293,G__G__Graf_186_0_54, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"H - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FloodFill",891,G__G__Graf_186_0_55, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - - 10 - - C - - 10 - - "
"C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCubeBezier",1390,G__G__Graf_186_0_56, 121, -1, -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - - 10 '\"#000000\"' - h - 'UInt_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawStraightEllips",1853,G__G__Graf_186_0_57, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - - 10 '\"#000000\"' - i - 'Int_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCircle",992,G__G__Graf_186_0_58, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - C - - 10 '\"#000000\"' - "
"i - 'Int_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawEllips",1015,G__G__Graf_186_0_59, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - C - - 10 '\"#000000\"' - "
"i - 'Int_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawEllips2",1065,G__G__Graf_186_0_60, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - C - - 10 '\"#000000\"' - "
"i - 'Int_t' 0 '1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditable",1094,G__G__Graf_186_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEditable",982,G__G__Graf_186_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidth",800,G__G__Graf_186_0_63, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHeight",889,G__G__Graf_186_0_64, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,G__G__Graf_186_0_65, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScaledImage",1359,G__G__Graf_186_0_66, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPixels",917,G__G__Graf_186_0_67, 85, G__get_linked_tagnum(&G__G__GrafLN_TArrayL), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '0' - i - 'Int_t' 0 '0' - "
"h - 'UInt_t' 0 '0' - h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArray",799,G__G__Graf_186_0_68, 85, G__get_linked_tagnum(&G__G__GrafLN_TArrayD), -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"U 'TImagePalette' - 0 'gWebImagePalette' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPixmap",911,G__G__Graf_186_0_69, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMask",684,G__G__Graf_186_0_70, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArgbArray",1179,G__G__Graf_186_0_71, 72, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRgbaArray",1179,G__G__Graf_186_0_72, 72, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVecArray",1085,G__G__Graf_186_0_73, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScanline",1101,G__G__Graf_186_0_74, 72, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetImageBuffer",1373,G__G__Graf_186_0_75, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 2 - - I - - 0 - - "
"i 'TImage::EImageFileTypes' - 0 'TImage::kPng' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImageBuffer",1385,G__G__Graf_186_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 2 - - i 'TImage::EImageFileTypes' - 0 'TImage::kPng' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintImage",991,G__G__Graf_186_0_77, 121, -1, -1, 0, 8, 1, 1, 0, 
"k - 'Drawable_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FromWindow",1036,G__G__Graf_186_0_78, 121, -1, -1, 0, 5, 1, 1, 0, 
"k - 'Drawable_t' 0 - - i - 'Int_t' 0 '0' - "
"i - 'Int_t' 0 '0' - h - 'UInt_t' 0 '0' - "
"h - 'UInt_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FromGLBuffer",1153,G__G__Graf_186_0_79, 121, -1, -1, 0, 3, 1, 1, 0, 
"B - 'UChar_t' 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetImageFileTypeFromFilename",2778,G__G__Graf_186_0_80, 105, G__get_linked_tagnum(&G__G__GrafLN_TImagecLcLEImageFileTypes), -1, 0, 1, 3, 1, 0, "C - - 10 - opt", (char*)NULL, (void*) G__func2void( (TImage::EImageFileTypes (*)(const char*))(&TImage::GetImageFileTypeFromFilename) ), 0);
   G__memfunc_setup("Create",596,G__G__Graf_186_0_81, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TImage* (*)())(&TImage::Create) ), 0);
   G__memfunc_setup("Open",402,G__G__Graf_186_0_82, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 2, 3, 1, 0, 
"C - - 10 - file i 'TImage::EImageFileTypes' - 0 'kUnknown' type", (char*)NULL, (void*) G__func2void( (TImage* (*)(const char*, TImage::EImageFileTypes))(&TImage::Open) ), 0);
   G__memfunc_setup("Open",402,G__G__Graf_186_0_83, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 1, 3, 1, 0, "C - - 2 - data", (char*)NULL, (void*) G__func2void( (TImage* (*)(char**))(&TImage::Open) ), 0);
   G__memfunc_setup("Open",402,G__G__Graf_186_0_84, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 5, 3, 1, 0, 
"C - - 10 - name D - 'Double_t' 10 - imageData "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"U 'TImagePalette' - 0 - palette", (char*)NULL, (void*) G__func2void( (TImage* (*)(const char*, const Double_t*, UInt_t, UInt_t, TImagePalette*))(&TImage::Open) ), 0);
   G__memfunc_setup("Open",402,G__G__Graf_186_0_85, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 4, 3, 1, 0, 
"C - - 10 - name u 'TArrayD' - 11 - imageData "
"h - 'UInt_t' 0 - width U 'TImagePalette' - 0 '0' palette", (char*)NULL, (void*) G__func2void( (TImage* (*)(const char*, const TArrayD&, UInt_t, TImagePalette*))(&TImage::Open) ), 0);
   G__memfunc_setup("Open",402,G__G__Graf_186_0_86, 85, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 4, 3, 1, 0, 
"C - - 10 - name u 'TVectorT<double>' 'TVectorD' 11 - imageData "
"h - 'UInt_t' 0 - width U 'TImagePalette' - 0 '0' palette", (char*)NULL, (void*) G__func2void( (TImage* (*)(const char*, const TVectorD&, UInt_t, TImagePalette*))(&TImage::Open) ), 0);
   G__memfunc_setup("operator+=",980,G__G__Graf_186_0_87, 117, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 1, 1, 1, 1, 0, "u 'TImage' - 11 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Graf_186_0_88, 117, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 1, 1, 1, 1, 0, "u 'TImage' - 11 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_186_0_89, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TImage::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_186_0_90, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImage::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_186_0_91, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TImage::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_186_0_92, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TImage::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_186_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_186_0_97, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImage::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_186_0_98, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TImage::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_186_0_99, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImage::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_186_0_100, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TImage::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TImage", 693, G__G__Graf_186_0_101, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTImagePlugin(void) {
   /* TImagePlugin */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TImagePlugin));
   G__memfunc_setup("ReadFile",764,G__G__Graf_193_0_2, 66, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - filename h - 'UInt_t' 1 - w "
"h - 'UInt_t' 1 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteFile",907,G__G__Graf_193_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"C - - 10 - filename B - - 0 - argb "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_193_0_5, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TImagePlugin::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_193_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImagePlugin::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_193_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TImagePlugin::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_193_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TImagePlugin::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_193_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_193_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImagePlugin::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_193_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TImagePlugin::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_193_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TImagePlugin::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_193_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TImagePlugin::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TImagePlugin", 1316, G__G__Graf_193_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_193_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TImagePlugin), -1, 1, 1, 1, 1, 0, "u 'TImagePlugin' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLatex(void) {
   /* TLatex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TLatex));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLatex), -1, 1, 1, 1, 2, 0, "u 'TLatex' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Analyse",717,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLatexFormSize), -1, 0, 5, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"u 'TextSpec_t' - 0 - spec C - 'Char_t' 10 - t "
"i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Anal1",429,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLatexFormSize), -1, 0, 3, 1, 2, 0, 
"u 'TextSpec_t' - 0 - spec C - 'Char_t' 10 - t "
"i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawLine",790,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"u 'TextSpec_t' - 0 - spec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCircle",992,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - r u 'TextSpec_t' - 0 - spec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawParenthesis",1556,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - r1 d - 'Double_t' 0 - r2 "
"d - 'Double_t' 0 - phimin d - 'Double_t' 0 - phimax "
"u 'TextSpec_t' - 0 - spec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FirstParse",1027,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLatexFormSize), -1, 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - angle d - 'Double_t' 0 - size "
"C - 'Char_t' 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Savefs",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TLatexFormSize' - 0 - fs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Readfs",597,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLatexFormSize), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckLatexSyntax",1635,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "u 'TString' - 1 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLatex",594,G__G__Graf_197_0_11, 105, G__get_linked_tagnum(&G__G__GrafLN_TLatex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLatex",594,G__G__Graf_197_0_12, 105, G__get_linked_tagnum(&G__G__GrafLN_TLatex), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLatex",594,G__G__Graf_197_0_13, 105, G__get_linked_tagnum(&G__G__GrafLN_TLatex), -1, 0, 1, 1, 1, 0, "u 'TLatex' - 11 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLatex",908,G__G__Graf_197_0_15, 85, G__get_linked_tagnum(&G__G__GrafLN_TLatex), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeight",889,G__G__Graf_197_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXsize",819,G__G__Graf_197_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYsize",820,G__G__Graf_197_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoundingBox",1407,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h "
"g - 'Bool_t' 0 'kFALSE' angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintLatex",1018,G__G__Graf_197_0_21, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - angle d - 'Double_t' 0 - size "
"C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIndiceSize",1299,G__G__Graf_197_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factorSize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimitIndiceSize",1810,G__G__Graf_197_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - limitFactorSize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_197_0_25, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLatex::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_197_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLatex::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_197_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLatex::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_197_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLatex::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_197_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_197_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLatex::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_197_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLatex::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_197_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLatex::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_197_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLatex::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLatex", 720, G__G__Graf_197_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLegendEntry(void) {
   /* TLegendEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry));
   G__memfunc_setup("TLegendEntry",1205,G__G__Graf_199_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLegendEntry",1205,G__G__Graf_199_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 10 - obj C - - 10 '0' label "
"C - 'Option_t' 10 '\"lpf\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLegendEntry",1205,G__G__Graf_199_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 0, 1, 1, 1, 0, "u 'TLegendEntry' - 11 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabel",768,G__G__Graf_199_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObject",887,G__G__Graf_199_0_6, 85, G__get_linked_tagnum(&G__G__GrafLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveEntry",929,G__G__Graf_199_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabel",780,G__G__Graf_199_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' label", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Graf_199_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Graf_199_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - objectName", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Graf_199_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"lpf\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 1, 1, 1, 4, 0, "u 'TLegendEntry' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_199_0_15, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLegendEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_199_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLegendEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_199_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLegendEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_199_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLegendEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_199_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_199_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLegendEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_199_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLegendEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_199_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLegendEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_199_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLegendEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLegendEntry", 1331, G__G__Graf_199_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLegend(void) {
   /* TLegend */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TLegend));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GrafLN_TLegend), -1, 1, 1, 1, 2, 0, "u 'TLegend' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLegend",675,G__G__Graf_200_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TLegend), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLegend",675,G__G__Graf_200_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TLegend), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - - 10 '\"\"' header C - 'Option_t' 10 '\"brNDC\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLegend",675,G__G__Graf_200_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TLegend), -1, 0, 1, 1, 1, 0, "u 'TLegend' - 11 - legend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEntry",795,G__G__Graf_200_0_5, 85, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 10 - obj C - - 10 '\"\"' label "
"C - 'Option_t' 10 '\"lpf\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEntry",795,G__G__Graf_200_0_6, 85, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' label "
"C - 'Option_t' 10 '\"lpf\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteEntry",1125,G__G__Graf_200_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EditEntryAttFill",1608,G__G__Graf_200_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EditEntryAttLine",1609,G__G__Graf_200_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EditEntryAttMarker",1827,G__G__Graf_200_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EditEntryAttText",1638,G__G__Graf_200_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnSeparation",1956,G__G__Graf_200_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,G__G__Graf_200_0_16, 85, G__get_linked_tagnum(&G__G__GrafLN_TLegendEntry), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntrySeparation",1864,G__G__Graf_200_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeader",873,G__G__Graf_200_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfPrimitives",1949,G__G__Graf_200_0_19, 85, G__get_linked_tagnum(&G__G__GrafLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMargin",894,G__G__Graf_200_0_20, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNColumns",1103,G__G__Graf_200_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNRows",793,G__G__Graf_200_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertEntry",1159,G__G__Graf_200_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 '\"\"' objectName C - - 10 '\"\"' label "
"C - 'Option_t' 10 '\"lpf\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPrimitives",1576,G__G__Graf_200_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaults",1124,G__G__Graf_200_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColumnSeparation",1968,G__G__Graf_200_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - columnSeparation", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetEntryLabel",1310,G__G__Graf_200_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetEntryOption",1463,G__G__Graf_200_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetEntrySeparation",1876,G__G__Graf_200_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - entryseparation", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetHeader",885,G__G__Graf_200_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' header", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMargin",906,G__G__Graf_200_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - margin", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetNColumns",1115,G__G__Graf_200_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nColumns", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_200_0_37, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLegend::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_200_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLegend::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_200_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLegend::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_200_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLegend::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_200_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_200_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLegend::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_200_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLegend::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_200_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLegend::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_200_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLegend::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLegend", 801, G__G__Graf_200_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLink(void) {
   /* TLink */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TLink));
   G__memfunc_setup("TLink",482,G__G__Graf_201_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TLink), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLink",482,G__G__Graf_201_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TLink), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"Y - - 0 - pointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_201_0_4, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLink::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_201_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLink::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_201_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLink::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_201_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLink::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_201_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_201_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLink::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_201_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLink::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLink::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLink::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLink", 482, G__G__Graf_201_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TLink), -1, 0, 1, 1, 1, 0, "u 'TLink' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLink", 608, G__G__Graf_201_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_201_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TLink), -1, 1, 1, 1, 1, 0, "u 'TLink' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMarker(void) {
   /* TMarker */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TMarker));
   G__memfunc_setup("TMarker",694,G__G__Graf_203_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TMarker), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMarker",694,G__G__Graf_203_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TMarker), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"i - 'Int_t' 0 - marker", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMarker",694,G__G__Graf_203_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TMarker), -1, 0, 1, 1, 1, 0, "u 'TMarker' - 11 - marker", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - marker", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawMarker",1008,G__G__Graf_203_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,G__G__Graf_203_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Graf_203_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintMarker",1118,G__G__Graf_203_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintMarkerNDC",1331,G__G__Graf_203_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - u d - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNDC",513,G__G__Graf_203_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' isNDC", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetX",388,G__G__Graf_203_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetY",389,G__G__Graf_203_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DisplayMarkerTypes",1869,G__G__Graf_203_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMarker::DisplayMarkerTypes) ), 0);
   G__memfunc_setup("Class",502,G__G__Graf_203_0_21, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMarker::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_203_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMarker::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_203_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMarker::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_203_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMarker::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_203_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_203_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMarker::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_203_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMarker::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_203_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMarker::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_203_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMarker::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMarker", 820, G__G__Graf_203_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_203_0_34, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TMarker), -1, 1, 1, 1, 1, 0, "u 'TMarker' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPaveLabel(void) {
   /* TPaveLabel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel));
   G__memfunc_setup("TPaveLabel",960,G__G__Graf_205_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPaveLabel",960,G__G__Graf_205_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - - 10 - label C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPaveLabel",960,G__G__Graf_205_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel), -1, 0, 1, 1, 1, 0, "u 'TPaveLabel' - 11 - pavelabel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - pavelabel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPaveLabel",1274,G__G__Graf_205_0_6, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - - 10 - label C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabel",768,G__G__Graf_205_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPaveLabel",1384,G__G__Graf_205_0_10, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - - 10 - label C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabel",780,G__G__Graf_205_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_205_0_13, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPaveLabel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_205_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveLabel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_205_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPaveLabel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_205_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPaveLabel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_205_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_205_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveLabel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_205_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveLabel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_205_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveLabel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_205_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveLabel::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPaveLabel", 1086, G__G__Graf_205_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_205_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPaveLabel), -1, 1, 1, 1, 1, 0, "u 'TPaveLabel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPaveStats(void) {
   /* TPaveStats */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPaveStats));
   G__memfunc_setup("TPaveStats",1007,G__G__Graf_206_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveStats), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPaveStats",1007,G__G__Graf_206_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPaveStats), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBox",562,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TBox), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLine",657,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TLine), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteText",1016,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EditText",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFitFormat",1196,G__G__Graf_206_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStatFormat",1317,G__G__Graf_206_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOptFit",886,G__G__Graf_206_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptStat",1007,G__G__Graf_206_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Graf_206_0_11, 85, G__get_linked_tagnum(&G__G__GrafLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertText",1050,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertLine",1021,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFile",764,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - - C - 'Option_t' 10 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveStyle",928,G__G__Graf_206_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetAllWith",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - - C - 'Option_t' 10 - - "
"d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMargin",906,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFitFormat",1208,G__G__Graf_206_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"5.4g\"' format", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetStatFormat",1329,G__G__Graf_206_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"6.4g\"' format", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetOptFit",898,G__G__Graf_206_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' fit", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetOptStat",1019,G__G__Graf_206_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' stat", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetParent",918,G__G__Graf_206_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_206_0_26, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPaveStats::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_206_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStats::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_206_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPaveStats::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_206_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPaveStats::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_206_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_206_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStats::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_206_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveStats::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_206_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStats::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_206_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveStats::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPaveStats", 1007, G__G__Graf_206_0_38, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TPaveStats), -1, 0, 1, 1, 1, 0, "u 'TPaveStats' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPaveStats", 1133, G__G__Graf_206_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_206_0_40, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPaveStats), -1, 1, 1, 1, 1, 0, "u 'TPaveStats' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPavesText(void) {
   /* TPavesText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPavesText));
   G__memfunc_setup("TPavesText",1016,G__G__Graf_207_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPavesText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPavesText",1016,G__G__Graf_207_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPavesText), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i - 'Int_t' 0 '5' npaves C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPavesText",1016,G__G__Graf_207_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPavesText), -1, 0, 1, 1, 1, 0, "u 'TPavesText' - 11 - pavestext", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpaves",909,G__G__Graf_207_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNpaves",921,G__G__Graf_207_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '5' npaves", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Graf_207_0_9, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPavesText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_207_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPavesText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_207_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPavesText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_207_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPavesText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_207_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_207_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPavesText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_207_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPavesText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_207_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPavesText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_207_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPavesText::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPavesText", 1142, G__G__Graf_207_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_207_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPavesText), -1, 1, 1, 1, 1, 0, "u 'TPavesText' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPieSlice(void) {
   /* TPieSlice */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPieSlice));
   G__memfunc_setup("TPieSlice",866,G__G__Graf_208_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPieSlice), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPieSlice",866,G__G__Graf_208_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPieSlice), -1, 0, 4, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"U 'TPie' - 0 - - d - 'Double_t' 0 '0' val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRadiusOffset",1519,G__G__Graf_208_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Graf_208_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' opts", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIsActive",1092,G__G__Graf_208_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - is", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRadiusOffset",1531,G__G__Graf_208_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Graf_208_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_208_0_10, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPieSlice::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_208_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSlice::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_208_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPieSlice::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_208_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPieSlice::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_208_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_208_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSlice::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_208_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieSlice::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_208_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSlice::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_208_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieSlice::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPieSlice", 866, G__G__Graf_208_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TPieSlice), -1, 0, 1, 1, 1, 0, "u 'TPieSlice' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPieSlice", 992, G__G__Graf_208_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_208_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPieSlice), -1, 1, 1, 1, 1, 0, "u 'TPieSlice' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPie(void) {
   /* TPie */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPie));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"i - 'Int_t' 0 - np d - 'Double_t' 0 - ao "
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawGhost",915,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPie",370,G__G__Graf_209_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPie",370,G__G__Graf_209_0_4, 105, G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 0, 3, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPie",370,G__G__Graf_209_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 0, 6, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 0 - - "
"I - 'Int_t' 0 '0' cols C - - 12 '0' lbls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPie",370,G__G__Graf_209_0_6, 105, G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 0, 6, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"i - 'Int_t' 0 - - F - 'Float_t' 0 - - "
"I - 'Int_t' 0 '0' cols C - - 12 '0' lbls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPie",370,G__G__Graf_209_0_7, 105, G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPie",370,G__G__Graf_209_0_8, 105, G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 0, 1, 1, 1, 0, "u 'TPie' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoSlice",1534,G__G__Graf_209_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"l\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAngle3D",894,G__G__Graf_209_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAngularOffset",1617,G__G__Graf_209_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryFillColor",1720,G__G__Graf_209_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryFillStyle",1738,G__G__Graf_209_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryLabel",1298,G__G__Graf_209_0_17, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryLineColor",1721,G__G__Graf_209_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryLineStyle",1739,G__G__Graf_209_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryLineWidth",1722,G__G__Graf_209_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryRadiusOffset",2049,G__G__Graf_209_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryVal",1109,G__G__Graf_209_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFractionFormat",1727,G__G__Graf_209_0_23, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeight",889,G__G__Graf_209_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelFormat",1385,G__G__Graf_209_0_25, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelsOffset",1498,G__G__Graf_209_0_26, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLegend",879,G__G__Graf_209_0_27, 85, G__get_linked_tagnum(&G__G__GrafLN_TLegend), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Graf_209_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPercentFormat",1626,G__G__Graf_209_0_29, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRadius",904,G__G__Graf_209_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlice",784,G__G__Graf_209_0_31, 85, G__get_linked_tagnum(&G__G__GrafLN_TPieSlice), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueFormat",1414,G__G__Graf_209_0_32, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Graf_209_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Graf_209_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeLegend",973,G__G__Graf_209_0_35, 85, G__get_linked_tagnum(&G__G__GrafLN_TLegend), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 '.65' x1 d - 'Double_t' 0 '.65' y1 "
"d - 'Double_t' 0 '.95' x2 d - 'Double_t' 0 '.95' y2 "
"C - - 10 '\"\"' leg_header", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeSlices",993,G__G__Graf_209_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' opts", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAngle3D",906,G__G__Graf_209_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '30.' val", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetAngularOffset",1629,G__G__Graf_209_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCircle",894,G__G__Graf_209_0_41, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 '.5' x d - 'Double_t' 0 '.5' y "
"d - 'Double_t' 0 '.4' rad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryLabel",1310,G__G__Graf_209_0_42, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - C - - 10 '\"Slice\"' text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryLineColor",1733,G__G__Graf_209_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryLineStyle",1751,G__G__Graf_209_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryLineWidth",1734,G__G__Graf_209_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryFillColor",1732,G__G__Graf_209_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryFillStyle",1750,G__G__Graf_209_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryRadiusOffset",2061,G__G__Graf_209_0_48, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntryVal",1121,G__G__Graf_209_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillColors",1317,G__G__Graf_209_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFractionFormat",1739,G__G__Graf_209_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetHeight",901,G__G__Graf_209_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '.08' val", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLabelFormat",1397,G__G__Graf_209_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLabels",895,G__G__Graf_209_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelsOffset",1510,G__G__Graf_209_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPercentFormat",1638,G__G__Graf_209_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetRadius",916,G__G__Graf_209_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetValueFormat",1426,G__G__Graf_209_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__G__Graf_209_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__G__Graf_209_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SortSlices",1035,G__G__Graf_209_0_61, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' amode f - 'Float_t' 0 '.0' merge_thresold", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_209_0_62, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPie::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_209_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPie::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_209_0_64, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPie::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_209_0_65, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPie::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_209_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_209_0_70, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPie::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_209_0_71, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPie::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_209_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPie::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_209_0_73, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPie::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPie", 496, G__G__Graf_209_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_209_0_75, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPie), -1, 1, 1, 1, 1, 0, "u 'TPie' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPoints(void) {
   /* TPoints */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TPoints));
   G__memfunc_setup("TPoints",721,G__G__Graf_210_0_1, 105, G__get_linked_tagnum(&G__G__GrafLN_TPoints), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints",721,G__G__Graf_210_0_2, 105, G__get_linked_tagnum(&G__G__GrafLN_TPoints), -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - xy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints",721,G__G__Graf_210_0_3, 105, G__get_linked_tagnum(&G__G__GrafLN_TPoints), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Graf_210_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Graf_210_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__G__Graf_210_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__G__Graf_210_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Graf_210_0_8, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPoints::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_210_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_210_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPoints::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_210_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPoints::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Graf_210_0_12, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Graf_210_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Graf_210_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_210_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_210_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_210_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPoints::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_210_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_210_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPoints::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPoints", 721, G__G__Graf_210_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TPoints), -1, 0, 1, 1, 1, 0, "u 'TPoints' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPoints", 847, G__G__Graf_210_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_210_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TPoints), -1, 1, 1, 1, 1, 0, "u 'TPoints' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTF(void) {
   /* TTF */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GrafLN_TTF));
   G__memfunc_setup("CharToUnicode",1288,G__G__Graf_218_0_1, 115, -1, G__defined_typename("Short_t"), 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - code", (char*)NULL, (void*) G__func2void( (Short_t (*)(UInt_t))(&TTF::CharToUnicode) ), 0);
   G__memfunc_setup("LayoutGlyphs",1269,G__G__Graf_218_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTF::LayoutGlyphs) ), 0);
   G__memfunc_setup("PrepareString",1350,G__G__Graf_218_0_3, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - string", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TTF::PrepareString) ), 0);
   G__memfunc_setup("SetRotationMatrix",1777,G__G__Graf_218_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - angle", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TTF::SetRotationMatrix) ), 0);
   G__memfunc_setup("TTF",238,G__G__Graf_218_0_5, 105, G__get_linked_tagnum(&G__G__GrafLN_TTF), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__Graf_218_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTF::Init) ), 0);
   G__memfunc_setup("Cleanup",712,G__G__Graf_218_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTF::Cleanup) ), 0);
   G__memfunc_setup("GetAscent",894,G__G__Graf_218_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TTF::GetAscent) ), 0);
   G__memfunc_setup("GetBox",585,G__G__Graf_218_0_9, 117, G__get_linked_tagnum(&G__G__GrafLN_FT_BBox), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const FT_BBox& (*)())(&TTF::GetBox) ), 0);
   G__memfunc_setup("GetGlyphs",919,G__G__Graf_218_0_10, 85, G__get_linked_tagnum(&G__G__GrafLN_TTGlyph), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TTGlyph* (*)())(&TTF::GetGlyphs) ), 0);
   G__memfunc_setup("GetHinting",1009,G__G__Graf_218_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TTF::GetHinting) ), 0);
   G__memfunc_setup("GetKerning",1006,G__G__Graf_218_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TTF::GetKerning) ), 0);
   G__memfunc_setup("GetNumGlyphs",1223,G__G__Graf_218_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TTF::GetNumGlyphs) ), 0);
   G__memfunc_setup("GetRotMatrix",1226,G__G__Graf_218_0_14, 85, G__get_linked_tagnum(&G__G__GrafLN_FT_Matrix), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FT_Matrix* (*)())(&TTF::GetRotMatrix) ), 0);
   G__memfunc_setup("GetSmoothing",1240,G__G__Graf_218_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TTF::GetSmoothing) ), 0);
   G__memfunc_setup("GetWidth",800,G__G__Graf_218_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TTF::GetWidth) ), 0);
   G__memfunc_setup("SetHinting",1021,G__G__Graf_218_0_17, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TTF::SetHinting) ), 0);
   G__memfunc_setup("SetKerning",1018,G__G__Graf_218_0_18, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TTF::SetKerning) ), 0);
   G__memfunc_setup("SetSmoothing",1252,G__G__Graf_218_0_19, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TTF::SetSmoothing) ), 0);
   G__memfunc_setup("GetTextExtent",1341,G__G__Graf_218_0_20, 121, -1, -1, 0, 3, 3, 1, 0, 
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h "
"C - - 0 - text", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t&, UInt_t&, char*))(&TTF::GetTextExtent) ), 0);
   G__memfunc_setup("GetTextAdvance",1399,G__G__Graf_218_0_21, 121, -1, -1, 0, 2, 3, 1, 0, 
"h - 'UInt_t' 1 - a C - - 0 - text", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t&, char*))(&TTF::GetTextAdvance) ), 0);
   G__memfunc_setup("SetTextFont",1128,G__G__Graf_218_0_22, 121, -1, -1, 0, 1, 3, 1, 0, "s - 'Font_t' 0 - fontnumber", (char*)NULL, (void*) G__func2void( (void (*)(Font_t))(&TTF::SetTextFont) ), 0);
   G__memfunc_setup("SetTextFont",1128,G__G__Graf_218_0_23, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"C - - 10 - fontname i - 'Int_t' 0 '0' italic", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*, Int_t))(&TTF::SetTextFont) ), 0);
   G__memfunc_setup("SetTextSize",1132,G__G__Graf_218_0_24, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - textsize", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TTF::SetTextSize) ), 0);
   G__memfunc_setup("IsInitialized",1330,G__G__Graf_218_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TTF::IsInitialized) ), 0);
   G__memfunc_setup("Version",742,G__G__Graf_218_0_26, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 1 - major i - 'Int_t' 1 - minor "
"i - 'Int_t' 1 - patch", (char*)NULL, (void*) G__func2void( (void (*)(Int_t&, Int_t&, Int_t&))(&TTF::Version) ), 0);
   G__memfunc_setup("Class",502,G__G__Graf_218_0_27, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTF::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Graf_218_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTF::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Graf_218_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTF::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Graf_218_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTF::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Graf_218_0_31, 85, G__get_linked_tagnum(&G__G__GrafLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Graf_218_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Graf_218_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Graf_218_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Graf_218_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTF::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Graf_218_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTF::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Graf_218_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTF::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Graf_218_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTF::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTF", 238, G__G__Graf_218_0_39, (int) ('i'), G__get_linked_tagnum(&G__G__GrafLN_TTF), -1, 0, 1, 1, 1, 0, "u 'TTF' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTF", 364, G__G__Graf_218_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Graf_218_0_41, (int) ('u'), G__get_linked_tagnum(&G__G__GrafLN_TTF), -1, 1, 1, 1, 1, 0, "u 'TTF' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Graf() {
}

/*********************************************************
* 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() {
   G__memvar_setup((void*)(&gHistImagePalette),85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TImagePalette),-1,-1,1,"gHistImagePalette=",0,(char*)NULL);
   G__memvar_setup((void*)(&gWebImagePalette),85,0,0,G__get_linked_tagnum(&G__G__GrafLN_TImagePalette),-1,-1,1,"gWebImagePalette=",0,(char*)NULL);
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Graf() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
   G__memfunc_setup("operator+", 919, G__G__Graf__0_343, 117, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 2, 1, 1, 0, 
"u 'TImage' - 11 - i1 u 'TImage' - 11 - s2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Graf__0_344, 117, G__get_linked_tagnum(&G__G__GrafLN_TImage), -1, 0, 2, 1, 1, 0, 
"u 'TImage' - 11 - i1 u 'TImage' - 11 - s2", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Graf() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__GrafLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TEllipse = { "TEllipse" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TEllipsecLcLdA = { "TEllipse::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TArc = { "TArc" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLine = { "TLine" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLinecLcLdA = { "TLine::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TArrow = { "TArrow" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TAttImage = { "TAttImage" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPaletteEditor = { "TPaletteEditor" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TImagePalette = { "TImagePalette" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TAttImagecLcLEImageQuality = { "TAttImage::EImageQuality" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TBox = { "TBox" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TBoxcLcLdA = { "TBox::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TCrown = { "TCrown" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPolyLine = { "TPolyLine" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPolyLinecLcLdA = { "TPolyLine::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TCurlyLine = { "TCurlyLine" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TCurlyLinecLcLdA = { "TCurlyLine::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TCurlyArc = { "TCurlyArc" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TAxis = { "TAxis" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TCutG = { "TCutG" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPave = { "TPave" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPavecLcLdA = { "TPave::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TAttText = { "TAttText" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TText = { "TText" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TTextcLcLdA = { "TText::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TPaveText = { "TPaveText" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TDiamond = { "TDiamond" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TWbox = { "TWbox" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TFrame = { "TFrame" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TGaxis = { "TGaxis" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TGraphPolargram = { "TGraphPolargram" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TGraphPolargramcLcLdA = { "TGraphPolargram::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TGraphErrors = { "TGraphErrors" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TGraphPolar = { "TGraphPolar" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TGraphQQ = { "TGraphQQ" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_Segment_t = { "Segment_t" , 115 , -1 };
G__linked_taginfo G__G__GrafLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TArrayD = { "TArrayD" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TArrayL = { "TArrayL" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPoint = { "TPoint" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TImage = { "TImage" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TImagecLcLEImageFileTypes = { "TImage::EImageFileTypes" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TImagecLcLEText3DType = { "TImage::EText3DType" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TImagecLcLECharType = { "TImage::ECharType" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TImagecLcLETileType = { "TImage::ETileType" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TImagecLcLECoordMode = { "TImage::ECoordMode" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TImagecLcLEColorChan = { "TImage::EColorChan" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TImagePlugin = { "TImagePlugin" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_FormSize_t = { "FormSize_t" , 115 , -1 };
G__linked_taginfo G__G__GrafLN_TextSpec_t = { "TextSpec_t" , 115 , -1 };
G__linked_taginfo G__G__GrafLN_TLatexFormSize = { "TLatexFormSize" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLatex = { "TLatex" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLatexcLcLdA = { "TLatex::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TLegendEntry = { "TLegendEntry" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLegend = { "TLegend" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLink = { "TLink" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TLinkcLcLdA = { "TLink::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TMarker = { "TMarker" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TMarkercLcLdA = { "TMarker::$" , 101 , -1 };
G__linked_taginfo G__G__GrafLN_TPaveLabel = { "TPaveLabel" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPaveStats = { "TPaveStats" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPavesText = { "TPavesText" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPieSlice = { "TPieSlice" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPie = { "TPie" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TPoints = { "TPoints" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_FT_BBox = { "FT_BBox" , 115 , -1 };
G__linked_taginfo G__G__GrafLN_FT_Matrix = { "FT_Matrix" , 115 , -1 };
G__linked_taginfo G__G__GrafLN_TTGlyph = { "TTGlyph" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TTF = { "TTF" , 99 , -1 };
G__linked_taginfo G__G__GrafLN_TTFcLcLdA = { "TTF::$" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Graf() {
  G__G__GrafLN_TClass.tagnum = -1 ;
  G__G__GrafLN_TBuffer.tagnum = -1 ;
  G__G__GrafLN_TMemberInspector.tagnum = -1 ;
  G__G__GrafLN_TObject.tagnum = -1 ;
  G__G__GrafLN_TNamed.tagnum = -1 ;
  G__G__GrafLN_TString.tagnum = -1 ;
  G__G__GrafLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__GrafLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__GrafLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GrafLN_TList.tagnum = -1 ;
  G__G__GrafLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__GrafLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GrafLN_TAttLine.tagnum = -1 ;
  G__G__GrafLN_TAttFill.tagnum = -1 ;
  G__G__GrafLN_TEllipse.tagnum = -1 ;
  G__G__GrafLN_TEllipsecLcLdA.tagnum = -1 ;
  G__G__GrafLN_TArc.tagnum = -1 ;
  G__G__GrafLN_TLine.tagnum = -1 ;
  G__G__GrafLN_TLinecLcLdA.tagnum = -1 ;
  G__G__GrafLN_TArrow.tagnum = -1 ;
  G__G__GrafLN_TAttImage.tagnum = -1 ;
  G__G__GrafLN_TPaletteEditor.tagnum = -1 ;
  G__G__GrafLN_TImagePalette.tagnum = -1 ;
  G__G__GrafLN_TAttImagecLcLEImageQuality.tagnum = -1 ;
  G__G__GrafLN_TBox.tagnum = -1 ;
  G__G__GrafLN_TBoxcLcLdA.tagnum = -1 ;
  G__G__GrafLN_TCrown.tagnum = -1 ;
  G__G__GrafLN_TCollection.tagnum = -1 ;
  G__G__GrafLN_TPolyLine.tagnum = -1 ;
  G__G__GrafLN_TPolyLinecLcLdA.tagnum = -1 ;
  G__G__GrafLN_TCurlyLine.tagnum = -1 ;
  G__G__GrafLN_TCurlyLinecLcLdA.tagnum = -1 ;
  G__G__GrafLN_TCurlyArc.tagnum = -1 ;
  G__G__GrafLN_TAttMarker.tagnum = -1 ;
  G__G__GrafLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__GrafLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__GrafLN_TAxis.tagnum = -1 ;
  G__G__GrafLN_TH1.tagnum = -1 ;
  G__G__GrafLN_TF1.tagnum = -1 ;
  G__G__GrafLN_TGraph.tagnum = -1 ;
  G__G__GrafLN_TH2.tagnum = -1 ;
  G__G__GrafLN_TCutG.tagnum = -1 ;
  G__G__GrafLN_TPave.tagnum = -1 ;
  G__G__GrafLN_TPavecLcLdA.tagnum = -1 ;
  G__G__GrafLN_TAttText.tagnum = -1 ;
  G__G__GrafLN_TText.tagnum = -1 ;
  G__G__GrafLN_TTextcLcLdA.tagnum = -1 ;
  G__G__GrafLN_TPaveText.tagnum = -1 ;
  G__G__GrafLN_TDiamond.tagnum = -1 ;
  G__G__GrafLN_TWbox.tagnum = -1 ;
  G__G__GrafLN_TFrame.tagnum = -1 ;
  G__G__GrafLN_TGaxis.tagnum = -1 ;
  G__G__GrafLN_TGraphPolargram.tagnum = -1 ;
  G__G__GrafLN_TGraphPolargramcLcLdA.tagnum = -1 ;
  G__G__GrafLN_TGraphErrors.tagnum = -1 ;
  G__G__GrafLN_TGraphPolar.tagnum = -1 ;
  G__G__GrafLN_TGraphQQ.tagnum = -1 ;
  G__G__GrafLN_Segment_t.tagnum = -1 ;
  G__G__GrafLN_TVirtualPad.tagnum = -1 ;
  G__G__GrafLN_TArrayD.tagnum = -1 ;
  G__G__GrafLN_TArrayL.tagnum = -1 ;
  G__G__GrafLN_TPoint.tagnum = -1 ;
  G__G__GrafLN_TImage.tagnum = -1 ;
  G__G__GrafLN_TImagecLcLEImageFileTypes.tagnum = -1 ;
  G__G__GrafLN_TImagecLcLEText3DType.tagnum = -1 ;
  G__G__GrafLN_TImagecLcLECharType.tagnum = -1 ;
  G__G__GrafLN_TImagecLcLETileType.tagnum = -1 ;
  G__G__GrafLN_TImagecLcLECoordMode.tagnum = -1 ;
  G__G__GrafLN_TImagecLcLEColorChan.tagnum = -1 ;
  G__G__GrafLN_TImagePlugin.tagnum = -1 ;
  G__G__GrafLN_FormSize_t.tagnum = -1 ;
  G__G__GrafLN_TextSpec_t.tagnum = -1 ;
  G__G__GrafLN_TLatexFormSize.tagnum = -1 ;
  G__G__GrafLN_TLatex.tagnum = -1 ;
  G__G__GrafLN_TLatexcLcLdA.tagnum = -1 ;
  G__G__GrafLN_TLegendEntry.tagnum = -1 ;
  G__G__GrafLN_TLegend.tagnum = -1 ;
  G__G__GrafLN_TLink.tagnum = -1 ;
  G__G__GrafLN_TLinkcLcLdA.tagnum = -1 ;
  G__G__GrafLN_TMarker.tagnum = -1 ;
  G__G__GrafLN_TMarkercLcLdA.tagnum = -1 ;
  G__G__GrafLN_TPaveLabel.tagnum = -1 ;
  G__G__GrafLN_TPaveStats.tagnum = -1 ;
  G__G__GrafLN_TPavesText.tagnum = -1 ;
  G__G__GrafLN_TPieSlice.tagnum = -1 ;
  G__G__GrafLN_TPie.tagnum = -1 ;
  G__G__GrafLN_TPoints.tagnum = -1 ;
  G__G__GrafLN_FT_BBox.tagnum = -1 ;
  G__G__GrafLN_FT_Matrix.tagnum = -1 ;
  G__G__GrafLN_TTGlyph.tagnum = -1 ;
  G__G__GrafLN_TTF.tagnum = -1 ;
  G__G__GrafLN_TTFcLcLdA.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Graf() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TString);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TList);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TAttFill);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TEllipse),sizeof(TEllipse),-1,128768,"An ellipse",G__setup_memvarTEllipse,G__setup_memfuncTEllipse);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TEllipsecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TArc),sizeof(TArc),-1,325376,"Arc of a circle",G__setup_memvarTArc,G__setup_memfuncTArc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TLine),sizeof(TLine),-1,128768,"A line segment",G__setup_memvarTLine,G__setup_memfuncTLine);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TLinecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TArrow),sizeof(TArrow),-1,325376,"An arrow (line with a arrowhead)",G__setup_memvarTArrow,G__setup_memfuncTArrow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TAttImage),sizeof(TAttImage),-1,34048,"Image attributes",G__setup_memvarTAttImage,G__setup_memfuncTAttImage);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPaletteEditor),sizeof(TPaletteEditor),-1,33792,"Base class for palette editor",G__setup_memvarTPaletteEditor,G__setup_memfuncTPaletteEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagePalette),sizeof(TImagePalette),-1,65280,"Color Palette for value -> color conversion",G__setup_memvarTImagePalette,G__setup_memfuncTImagePalette);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TAttImagecLcLEImageQuality);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TBox),sizeof(TBox),-1,130816,"Box class",G__setup_memvarTBox,G__setup_memfuncTBox);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TBoxcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TCrown),sizeof(TCrown),-1,325376,"A crown or segment of crown",G__setup_memvarTCrown,G__setup_memfuncTCrown);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPolyLine),sizeof(TPolyLine),-1,130816,"A PolyLine",G__setup_memvarTPolyLine,G__setup_memfuncTPolyLine);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TPolyLinecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TCurlyLine),sizeof(TCurlyLine),-1,324864,"A curly polyline",G__setup_memvarTCurlyLine,G__setup_memfuncTCurlyLine);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TCurlyLinecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TCurlyArc),sizeof(TCurlyArc),-1,324864,"A curly arc",G__setup_memvarTCurlyArc,G__setup_memfuncTCurlyArc);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TAxis);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TH1);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TF1);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TGraph);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TH2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TCutG),sizeof(TCutG),-1,128768,"A Graphical cut.",G__setup_memvarTCutG,G__setup_memfuncTCutG);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPave),sizeof(TPave),-1,128768,"Pave. A box with shadowing",G__setup_memvarTPave,G__setup_memfuncTPave);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TPavecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TAttText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TText),sizeof(TText),-1,128768,"Text",G__setup_memvarTText,G__setup_memfuncTText);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TTextcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPaveText),sizeof(TPaveText),-1,130816,"PaveText. A Pave with several lines of text.",G__setup_memvarTPaveText,G__setup_memfuncTPaveText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TDiamond),sizeof(TDiamond),-1,325376,"Diamond class",G__setup_memvarTDiamond,G__setup_memfuncTDiamond);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TWbox),sizeof(TWbox),-1,325376,"A window box (box with 3-D effects)",G__setup_memvarTWbox,G__setup_memfuncTWbox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TFrame),sizeof(TFrame),-1,325376,"Pad graphics frame",G__setup_memvarTFrame,G__setup_memfuncTFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TGaxis),sizeof(TGaxis),-1,130816,"Graphics axis",G__setup_memvarTGaxis,G__setup_memfuncTGaxis);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TGraphPolargram),sizeof(TGraphPolargram),-1,324864,"Polar axis",G__setup_memvarTGraphPolargram,G__setup_memfuncTGraphPolargram);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TGraphPolargramcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TGraphErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TGraphPolar),sizeof(TGraphPolar),-1,324864,"Polar graph",G__setup_memvarTGraphPolar,G__setup_memfuncTGraphPolar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TGraphQQ),sizeof(TGraphQQ),-1,324864,"to create and to draw quantile-quantile plots",G__setup_memvarTGraphQQ,G__setup_memfuncTGraphQQ);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_Segment_t);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TArrayD);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TArrayL);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TPoint);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImage),sizeof(TImage),-1,65280,"Abstract image class",G__setup_memvarTImage,G__setup_memfuncTImage);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagecLcLEImageFileTypes),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagecLcLEText3DType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagecLcLECharType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagecLcLETileType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagecLcLECoordMode),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagecLcLEColorChan),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TImagePlugin),sizeof(TImagePlugin),-1,62466,"base class for different image format handlers(plugins)",G__setup_memvarTImagePlugin,G__setup_memfuncTImagePlugin);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_FormSize_t);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TextSpec_t);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TLatexFormSize);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TLatex),sizeof(TLatex),-1,327424,"The Latex-style text processor class",G__setup_memvarTLatex,G__setup_memfuncTLatex);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TLatexcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TLegendEntry),sizeof(TLegendEntry),-1,327424,"Storage class for one entry of a TLegend",G__setup_memvarTLegendEntry,G__setup_memfuncTLegendEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TLegend),sizeof(TLegend),-1,327424,"Legend of markers/lines/boxes to represent obj's",G__setup_memvarTLegend,G__setup_memfuncTLegend);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TLink),sizeof(TLink),-1,324864,"Link: hypertext link to an object",G__setup_memvarTLink,G__setup_memfuncTLink);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TLinkcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TMarker),sizeof(TMarker),-1,128768,"Marker",G__setup_memvarTMarker,G__setup_memfuncTMarker);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TMarkercLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPaveLabel),sizeof(TPaveLabel),-1,325376,"PaveLabel. A Pave with a label",G__setup_memvarTPaveLabel,G__setup_memfuncTPaveLabel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPaveStats),sizeof(TPaveStats),-1,128256,"A special TPaveText to draw histogram statistics.",G__setup_memvarTPaveStats,G__setup_memfuncTPaveStats);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPavesText),sizeof(TPavesText),-1,325376,"Stacked Paves with text strings",G__setup_memvarTPavesText,G__setup_memfuncTPavesText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPieSlice),sizeof(TPieSlice),-1,324864,"Slice of a pie chart graphics class",G__setup_memvarTPieSlice,G__setup_memfuncTPieSlice);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPie),sizeof(TPie),-1,325376,"Pie chart graphics class",G__setup_memvarTPie,G__setup_memfuncTPie);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TPoints),sizeof(TPoints),-1,296192,"2-D graphics point",G__setup_memvarTPoints,G__setup_memfuncTPoints);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_FT_BBox);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_FT_Matrix);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TTGlyph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GrafLN_TTF),sizeof(TTF),-1,1280,"Interface to TTF font handling",G__setup_memvarTTF,G__setup_memfuncTTF);
   G__get_linked_tagnum_fwd(&G__G__GrafLN_TTFcLcLdA);
}
extern "C" void G__cpp_setupG__Graf(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Graf()");
  G__set_cpp_environmentG__Graf();
  G__cpp_setup_tagtableG__Graf();

  G__cpp_setup_inheritanceG__Graf();

  G__cpp_setup_typetableG__Graf();

  G__cpp_setup_memvarG__Graf();

  G__cpp_setup_memfuncG__Graf();
  G__cpp_setup_globalG__Graf();
  G__cpp_setup_funcG__Graf();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Graf();
  return;
}
class G__cpp_setup_initG__Graf {
  public:
    G__cpp_setup_initG__Graf() { G__add_setup_func("G__Graf",(G__incsetup)(&G__cpp_setupG__Graf)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Graf() { G__remove_setup_func("G__Graf"); }
};
G__cpp_setup_initG__Graf G__cpp_setup_initializerG__Graf;

---