G__Table.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 14:04:11 2011

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

#define R__DICTIONARY_FILENAME miscdItabledIsrcdIG__Table
#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__Table.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::tableDescriptor_st tableDescriptor_st;
      #else
      class tableDescriptor_st  {
         public:
         //friend XX;
         char fColumnName[32]; //The name of this data-member: see dstype.h for dsl compatible mode 
         unsigned int fIndexArray[3]; //The array of the sizes for each dimensions fIndexArray[fDimensions]
         unsigned int fOffset; //The first byte in the row of this column                              
         unsigned int fSize; //The full size of the selected column in bytes                         
         unsigned int fTypeSize; //The type size of the selected column in bytes                         
         unsigned int fDimensions; //The number of the dimensions for array                                
         int fType; //The data type of the selected column                                  
      };
      #endif

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

namespace ROOT {
   void tableDescriptor_st_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void tableDescriptor_st_Dictionary();
   static void *new_tableDescriptor_st(void *p = 0);
   static void *newArray_tableDescriptor_st(Long_t size, void *p);
   static void delete_tableDescriptor_st(void *p);
   static void deleteArray_tableDescriptor_st(void *p);
   static void destruct_tableDescriptor_st(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::tableDescriptor_st*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::tableDescriptor_st) == sizeof(::ROOT::Shadow::tableDescriptor_st));
      ::tableDescriptor_st *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::tableDescriptor_st),0);
      static ::ROOT::TGenericClassInfo 
         instance("tableDescriptor_st", "include/tableDescriptor.h", 72,
                  typeid(::tableDescriptor_st), DefineBehavior(ptr, ptr),
                  &tableDescriptor_st_ShowMembers, &tableDescriptor_st_Dictionary, isa_proxy, 4,
                  sizeof(::tableDescriptor_st) );
      instance.SetNew(&new_tableDescriptor_st);
      instance.SetNewArray(&newArray_tableDescriptor_st);
      instance.SetDelete(&delete_tableDescriptor_st);
      instance.SetDeleteArray(&deleteArray_tableDescriptor_st);
      instance.SetDestructor(&destruct_tableDescriptor_st);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::tableDescriptor_st*)
   {
      return GenerateInitInstanceLocal((::tableDescriptor_st*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::tableDescriptor_st*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TCL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCL(void *p = 0);
   static void *newArray_TCL(Long_t size, void *p);
   static void delete_TCL(void *p);
   static void deleteArray_TCL(void *p);
   static void destruct_TCL(void *p);
   static void streamer_TCL(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTable(void *p = 0);
   static void *newArray_TTable(Long_t size, void *p);
   static void delete_TTable(void *p);
   static void deleteArray_TTable(void *p);
   static void destruct_TTable(void *p);
   static void streamer_TTable(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDataSetIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDataSetIter(void *p = 0);
   static void *newArray_TDataSetIter(Long_t size, void *p);
   static void delete_TDataSetIter(void *p);
   static void deleteArray_TDataSetIter(void *p);
   static void destruct_TDataSetIter(void *p);
   static void streamer_TDataSetIter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TDataSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDataSet(void *p = 0);
   static void *newArray_TDataSet(Long_t size, void *p);
   static void delete_TDataSet(void *p);
   static void deleteArray_TDataSet(void *p);
   static void destruct_TDataSet(void *p);

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

namespace ROOT {
   void TTableDescriptor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTableDescriptor(void *p = 0);
   static void *newArray_TTableDescriptor(Long_t size, void *p);
   static void delete_TTableDescriptor(void *p);
   static void deleteArray_TTableDescriptor(void *p);
   static void destruct_TTableDescriptor(void *p);
   static void streamer_TTableDescriptor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTableDescriptor*)
   {
      ::TTableDescriptor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTableDescriptor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTableDescriptor", ::TTableDescriptor::Class_Version(), "include/TTableDescriptor.h", 25,
                  typeid(::TTableDescriptor), DefineBehavior(ptr, ptr),
                  &::TTableDescriptor::Dictionary, isa_proxy, 1,
                  sizeof(::TTableDescriptor) );
      instance.SetNew(&new_TTableDescriptor);
      instance.SetNewArray(&newArray_TTableDescriptor);
      instance.SetDelete(&delete_TTableDescriptor);
      instance.SetDeleteArray(&deleteArray_TTableDescriptor);
      instance.SetDestructor(&destruct_TTableDescriptor);
      instance.SetStreamerFunc(&streamer_TTableDescriptor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTableDescriptor*)
   {
      return GenerateInitInstanceLocal((::TTableDescriptor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTableDescriptor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTableMap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTableMap(void *p = 0);
   static void *newArray_TTableMap(Long_t size, void *p);
   static void delete_TTableMap(void *p);
   static void deleteArray_TTableMap(void *p);
   static void destruct_TTableMap(void *p);
   static void streamer_TTableMap(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TTablecLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TTablecLcLiterator_Dictionary();
   static void *new_TTablecLcLiterator(void *p = 0);
   static void *newArray_TTablecLcLiterator(Long_t size, void *p);
   static void delete_TTablecLcLiterator(void *p);
   static void deleteArray_TTablecLcLiterator(void *p);
   static void destruct_TTablecLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTable::iterator*)
   {
      ::TTable::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TTable::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("TTable::iterator", "include/TTable.h", 183,
                  typeid(::TTable::iterator), DefineBehavior(ptr, ptr),
                  0, &TTablecLcLiterator_Dictionary, isa_proxy, 3,
                  sizeof(::TTable::iterator) );
      instance.SetNew(&new_TTablecLcLiterator);
      instance.SetNewArray(&newArray_TTablecLcLiterator);
      instance.SetDelete(&delete_TTablecLcLiterator);
      instance.SetDeleteArray(&deleteArray_TTablecLcLiterator);
      instance.SetDestructor(&destruct_TTablecLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTable::iterator*)
   {
      return GenerateInitInstanceLocal((::TTable::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTable::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TTablecLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TTable::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TChair_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TChair(void *p);
   static void deleteArray_TChair(void *p);
   static void destruct_TChair(void *p);

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

namespace ROOT {
   void TColumnView_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TColumnView(void *p = 0);
   static void *newArray_TColumnView(Long_t size, void *p);
   static void delete_TColumnView(void *p);
   static void deleteArray_TColumnView(void *p);
   static void destruct_TColumnView(void *p);
   static void streamer_TColumnView(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TColumnView*)
   {
      ::TColumnView *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TColumnView >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TColumnView", ::TColumnView::Class_Version(), "include/TColumnView.h", 21,
                  typeid(::TColumnView), DefineBehavior(ptr, ptr),
                  &::TColumnView::Dictionary, isa_proxy, 0,
                  sizeof(::TColumnView) );
      instance.SetNew(&new_TColumnView);
      instance.SetNewArray(&newArray_TColumnView);
      instance.SetDelete(&delete_TColumnView);
      instance.SetDeleteArray(&deleteArray_TColumnView);
      instance.SetDestructor(&destruct_TColumnView);
      instance.SetStreamerFunc(&streamer_TColumnView);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TColumnView*)
   {
      return GenerateInitInstanceLocal((::TColumnView*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TColumnView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFileIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFileIter(void *p = 0);
   static void *newArray_TFileIter(Long_t size, void *p);
   static void delete_TFileIter(void *p);
   static void deleteArray_TFileIter(void *p);
   static void destruct_TFileIter(void *p);
   static void streamer_TFileIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFileIter*)
   {
      ::TFileIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFileIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFileIter", ::TFileIter::Class_Version(), "include/TFileIter.h", 61,
                  typeid(::TFileIter), DefineBehavior(ptr, ptr),
                  &::TFileIter::Dictionary, isa_proxy, 0,
                  sizeof(::TFileIter) );
      instance.SetNew(&new_TFileIter);
      instance.SetNewArray(&newArray_TFileIter);
      instance.SetDelete(&delete_TFileIter);
      instance.SetDeleteArray(&deleteArray_TFileIter);
      instance.SetDestructor(&destruct_TFileIter);
      instance.SetStreamerFunc(&streamer_TFileIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFileIter*)
   {
      return GenerateInitInstanceLocal((::TFileIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFileIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFileSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFileSet(void *p = 0);
   static void *newArray_TFileSet(Long_t size, void *p);
   static void delete_TFileSet(void *p);
   static void deleteArray_TFileSet(void *p);
   static void destruct_TFileSet(void *p);

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

namespace ROOT {
   void TGenericTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGenericTable(void *p = 0);
   static void *newArray_TGenericTable(Long_t size, void *p);
   static void delete_TGenericTable(void *p);
   static void deleteArray_TGenericTable(void *p);
   static void destruct_TGenericTable(void *p);
   static void streamer_TGenericTable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGenericTable*)
   {
      ::TGenericTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGenericTable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGenericTable", ::TGenericTable::Class_Version(), "include/TGenericTable.h", 17,
                  typeid(::TGenericTable), DefineBehavior(ptr, ptr),
                  &::TGenericTable::Dictionary, isa_proxy, 1,
                  sizeof(::TGenericTable) );
      instance.SetNew(&new_TGenericTable);
      instance.SetNewArray(&newArray_TGenericTable);
      instance.SetDelete(&delete_TGenericTable);
      instance.SetDeleteArray(&deleteArray_TGenericTable);
      instance.SetDestructor(&destruct_TGenericTable);
      instance.SetStreamerFunc(&streamer_TGenericTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGenericTable*)
   {
      return GenerateInitInstanceLocal((::TGenericTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGenericTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGenericTablecLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGenericTablecLcLiterator_Dictionary();
   static void delete_TGenericTablecLcLiterator(void *p);
   static void deleteArray_TGenericTablecLcLiterator(void *p);
   static void destruct_TGenericTablecLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGenericTable::iterator*)
   {
      ::TGenericTable::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGenericTable::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGenericTable::iterator", "include/TGenericTable.h", 25,
                  typeid(::TGenericTable::iterator), DefineBehavior(ptr, ptr),
                  0, &TGenericTablecLcLiterator_Dictionary, isa_proxy, 3,
                  sizeof(::TGenericTable::iterator) );
      instance.SetDelete(&delete_TGenericTablecLcLiterator);
      instance.SetDeleteArray(&deleteArray_TGenericTablecLcLiterator);
      instance.SetDestructor(&destruct_TGenericTablecLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGenericTable::iterator*)
   {
      return GenerateInitInstanceLocal((::TGenericTable::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGenericTable::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TGenericTablecLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TGenericTable::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TIndexTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TIndexTable(void *p = 0);
   static void *newArray_TIndexTable(Long_t size, void *p);
   static void delete_TIndexTable(void *p);
   static void deleteArray_TIndexTable(void *p);
   static void destruct_TIndexTable(void *p);
   static void streamer_TIndexTable(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TIndexTablecLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TIndexTablecLcLiterator_Dictionary();
   static void delete_TIndexTablecLcLiterator(void *p);
   static void deleteArray_TIndexTablecLcLiterator(void *p);
   static void destruct_TIndexTablecLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TIndexTable::iterator*)
   {
      ::TIndexTable::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TIndexTable::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("TIndexTable::iterator", "include/TIndexTable.h", 32,
                  typeid(::TIndexTable::iterator), DefineBehavior(ptr, ptr),
                  0, &TIndexTablecLcLiterator_Dictionary, isa_proxy, 3,
                  sizeof(::TIndexTable::iterator) );
      instance.SetDelete(&delete_TIndexTablecLcLiterator);
      instance.SetDeleteArray(&deleteArray_TIndexTablecLcLiterator);
      instance.SetDestructor(&destruct_TIndexTablecLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TIndexTable::iterator*)
   {
      return GenerateInitInstanceLocal((::TIndexTable::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TIndexTable::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TIndexTablecLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TIndexTable::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TObjectSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TObjectSet(void *p = 0);
   static void *newArray_TObjectSet(Long_t size, void *p);
   static void delete_TObjectSet(void *p);
   static void deleteArray_TObjectSet(void *p);
   static void destruct_TObjectSet(void *p);

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

namespace ROOT {
   void TPoints3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPoints3D(void *p = 0);
   static void *newArray_TPoints3D(Long_t size, void *p);
   static void delete_TPoints3D(void *p);
   static void deleteArray_TPoints3D(void *p);
   static void destruct_TPoints3D(void *p);

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

namespace ROOT {
   void TPointsArray3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPointsArray3D(void *p = 0);
   static void *newArray_TPointsArray3D(Long_t size, void *p);
   static void delete_TPointsArray3D(void *p);
   static void deleteArray_TPointsArray3D(void *p);
   static void destruct_TPointsArray3D(void *p);
   static void streamer_TPointsArray3D(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPolyLineShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPolyLineShape(void *p = 0);
   static void *newArray_TPolyLineShape(Long_t size, void *p);
   static void delete_TPolyLineShape(void *p);
   static void deleteArray_TPolyLineShape(void *p);
   static void destruct_TPolyLineShape(void *p);

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

namespace ROOT {
   void TResponseTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TResponseTable(void *p = 0);
   static void *newArray_TResponseTable(Long_t size, void *p);
   static void delete_TResponseTable(void *p);
   static void deleteArray_TResponseTable(void *p);
   static void destruct_TResponseTable(void *p);
   static void streamer_TResponseTable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TResponseTable*)
   {
      ::TResponseTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TResponseTable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TResponseTable", ::TResponseTable::Class_Version(), "include/TResponseTable.h", 15,
                  typeid(::TResponseTable), DefineBehavior(ptr, ptr),
                  &::TResponseTable::Dictionary, isa_proxy, 1,
                  sizeof(::TResponseTable) );
      instance.SetNew(&new_TResponseTable);
      instance.SetNewArray(&newArray_TResponseTable);
      instance.SetDelete(&delete_TResponseTable);
      instance.SetDeleteArray(&deleteArray_TResponseTable);
      instance.SetDestructor(&destruct_TResponseTable);
      instance.SetStreamerFunc(&streamer_TResponseTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TResponseTable*)
   {
      return GenerateInitInstanceLocal((::TResponseTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TResponseTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTableSorter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTableSorter(void *p = 0);
   static void *newArray_TTableSorter(Long_t size, void *p);
   static void delete_TTableSorter(void *p);
   static void deleteArray_TTableSorter(void *p);
   static void destruct_TTableSorter(void *p);
   static void streamer_TTableSorter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TTablePoints_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TTablePoints(void *p);
   static void deleteArray_TTablePoints(void *p);
   static void destruct_TTablePoints(void *p);

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

namespace ROOT {
   void TTable3Points_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTable3Points(void *p = 0);
   static void *newArray_TTable3Points(Long_t size, void *p);
   static void delete_TTable3Points(void *p);
   static void deleteArray_TTable3Points(void *p);
   static void destruct_TTable3Points(void *p);

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

namespace ROOT {
   void TTableIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TTableIter(void *p);
   static void deleteArray_TTableIter(void *p);
   static void destruct_TTableIter(void *p);
   static void streamer_TTableIter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TTablePadView3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TTablePadView3D_Dictionary();
   static void *new_TTablePadView3D(void *p = 0);
   static void *newArray_TTablePadView3D(Long_t size, void *p);
   static void delete_TTablePadView3D(void *p);
   static void deleteArray_TTablePadView3D(void *p);
   static void destruct_TTablePadView3D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTablePadView3D*)
   {
      ::TTablePadView3D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TTablePadView3D),0);
      static ::ROOT::TGenericClassInfo 
         instance("TTablePadView3D", "include/TTablePadView3D.h", 38,
                  typeid(::TTablePadView3D), DefineBehavior(ptr, ptr),
                  0, &TTablePadView3D_Dictionary, isa_proxy, 0,
                  sizeof(::TTablePadView3D) );
      instance.SetNew(&new_TTablePadView3D);
      instance.SetNewArray(&newArray_TTablePadView3D);
      instance.SetDelete(&delete_TTablePadView3D);
      instance.SetDeleteArray(&deleteArray_TTablePadView3D);
      instance.SetDestructor(&destruct_TTablePadView3D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTablePadView3D*)
   {
      return GenerateInitInstanceLocal((::TTablePadView3D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTablePadView3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TVolumePosition_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TVolumePosition(void *p = 0);
   static void *newArray_TVolumePosition(Long_t size, void *p);
   static void delete_TVolumePosition(void *p);
   static void deleteArray_TVolumePosition(void *p);
   static void destruct_TVolumePosition(void *p);
   static void streamer_TVolumePosition(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TVolume_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TVolume(void *p = 0);
   static void *newArray_TVolume(Long_t size, void *p);
   static void delete_TVolume(void *p);
   static void deleteArray_TVolume(void *p);
   static void destruct_TVolume(void *p);

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

namespace ROOT {
   void TVolumeView_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TVolumeView(void *p = 0);
   static void *newArray_TVolumeView(Long_t size, void *p);
   static void delete_TVolumeView(void *p);
   static void deleteArray_TVolumeView(void *p);
   static void destruct_TVolumeView(void *p);

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

namespace ROOT {
   void TVolumeViewIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVolumeViewIter(void *p);
   static void deleteArray_TVolumeViewIter(void *p);
   static void destruct_TVolumeViewIter(void *p);
   static void streamer_TVolumeViewIter(TBuffer &buf, void *obj);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDataSet(void *p) {
      return  p ? new(p) ::TDataSet : new ::TDataSet;
   }
   static void *newArray_TDataSet(Long_t nElements, void *p) {
      return p ? new(p) ::TDataSet[nElements] : new ::TDataSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDataSet(void *p) {
      delete ((::TDataSet*)p);
   }
   static void deleteArray_TDataSet(void *p) {
      delete [] ((::TDataSet*)p);
   }
   static void destruct_TDataSet(void *p) {
      typedef ::TDataSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDataSet

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TDataSetIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDataSetIter.
      TClass *R__cl = ::TDataSetIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNext", &fNext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextSet[100]", &fNextSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDepth", &fDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSet", &fDataSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootDataSet", &fRootDataSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkingDataSet", &fWorkingDataSet);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDataSetIter(void *p) {
      return  p ? new(p) ::TDataSetIter : new ::TDataSetIter;
   }
   static void *newArray_TDataSetIter(Long_t nElements, void *p) {
      return p ? new(p) ::TDataSetIter[nElements] : new ::TDataSetIter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDataSetIter(void *p) {
      delete ((::TDataSetIter*)p);
   }
   static void deleteArray_TDataSetIter(void *p) {
      delete [] ((::TDataSetIter*)p);
   }
   static void destruct_TDataSetIter(void *p) {
      typedef ::TDataSetIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDataSetIter(TBuffer &buf, void *obj) {
      ((::TDataSetIter*)obj)->::TDataSetIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDataSetIter

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFileSet(void *p) {
      return  p ? new(p) ::TFileSet : new ::TFileSet;
   }
   static void *newArray_TFileSet(Long_t nElements, void *p) {
      return p ? new(p) ::TFileSet[nElements] : new ::TFileSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFileSet(void *p) {
      delete ((::TFileSet*)p);
   }
   static void deleteArray_TFileSet(void *p) {
      delete [] ((::TFileSet*)p);
   }
   static void destruct_TFileSet(void *p) {
      typedef ::TFileSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFileSet

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

   TListIter::Streamer(R__b);
}

//______________________________________________________________________________
void TFileIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFileIter.
      TClass *R__cl = ::TFileIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileBackUp", &fFileBackUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectoryBackUp", &fDirectoryBackUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNestedIterator", &fNestedIterator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootFile", &fRootFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventName", &fEventName);
      R__insp.InspectMember(fEventName, "fEventName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRunNumber", &fRunNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventNumber", &fEventNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorPosition", &fCursorPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnTFile", &fOwnTFile);
      TListIter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFileIter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TFileIter : new ::TFileIter;
   }
   static void *newArray_TFileIter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TFileIter[nElements] : new ::TFileIter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFileIter(void *p) {
      delete ((::TFileIter*)p);
   }
   static void deleteArray_TFileIter(void *p) {
      delete [] ((::TFileIter*)p);
   }
   static void destruct_TFileIter(void *p) {
      typedef ::TFileIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFileIter(TBuffer &buf, void *obj) {
      ((::TFileIter*)obj)->::TFileIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFileIter

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TObjectSet(void *p) {
      return  p ? new(p) ::TObjectSet : new ::TObjectSet;
   }
   static void *newArray_TObjectSet(Long_t nElements, void *p) {
      return p ? new(p) ::TObjectSet[nElements] : new ::TObjectSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TObjectSet(void *p) {
      delete ((::TObjectSet*)p);
   }
   static void deleteArray_TObjectSet(void *p) {
      delete [] ((::TObjectSet*)p);
   }
   static void destruct_TObjectSet(void *p) {
      typedef ::TObjectSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TObjectSet

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCL : new ::TCL;
   }
   static void *newArray_TCL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCL[nElements] : new ::TCL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCL(void *p) {
      delete ((::TCL*)p);
   }
   static void deleteArray_TCL(void *p) {
      delete [] ((::TCL*)p);
   }
   static void destruct_TCL(void *p) {
      typedef ::TCL current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TCL(TBuffer &buf, void *obj) {
      ((::TCL*)obj)->::TCL::Streamer(buf);
   }
} // end of namespace ROOT for class ::TCL

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

   TObject::Streamer(R__b);
}

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTable(void *p) {
      return  p ? new(p) ::TTable : new ::TTable;
   }
   static void *newArray_TTable(Long_t nElements, void *p) {
      return p ? new(p) ::TTable[nElements] : new ::TTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTable(void *p) {
      delete ((::TTable*)p);
   }
   static void deleteArray_TTable(void *p) {
      delete [] ((::TTable*)p);
   }
   static void destruct_TTable(void *p) {
      typedef ::TTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTable(TBuffer &buf, void *obj) {
      ((::TTable*)obj)->::TTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTable

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTablecLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTable::iterator : new ::TTable::iterator;
   }
   static void *newArray_TTablecLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTable::iterator[nElements] : new ::TTable::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTablecLcLiterator(void *p) {
      delete ((::TTable::iterator*)p);
   }
   static void deleteArray_TTablecLcLiterator(void *p) {
      delete [] ((::TTable::iterator*)p);
   }
   static void destruct_TTablecLcLiterator(void *p) {
      typedef ::TTable::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTable::iterator

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGenericTable(void *p) {
      return  p ? new(p) ::TGenericTable : new ::TGenericTable;
   }
   static void *newArray_TGenericTable(Long_t nElements, void *p) {
      return p ? new(p) ::TGenericTable[nElements] : new ::TGenericTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGenericTable(void *p) {
      delete ((::TGenericTable*)p);
   }
   static void deleteArray_TGenericTable(void *p) {
      delete [] ((::TGenericTable*)p);
   }
   static void destruct_TGenericTable(void *p) {
      typedef ::TGenericTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGenericTable(TBuffer &buf, void *obj) {
      ((::TGenericTable*)obj)->::TGenericTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGenericTable

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGenericTablecLcLiterator(void *p) {
      delete ((::TGenericTable::iterator*)p);
   }
   static void deleteArray_TGenericTablecLcLiterator(void *p) {
      delete [] ((::TGenericTable::iterator*)p);
   }
   static void destruct_TGenericTablecLcLiterator(void *p) {
      typedef ::TGenericTable::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGenericTable::iterator

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TIndexTable(void *p) {
      return  p ? new(p) ::TIndexTable : new ::TIndexTable;
   }
   static void *newArray_TIndexTable(Long_t nElements, void *p) {
      return p ? new(p) ::TIndexTable[nElements] : new ::TIndexTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TIndexTable(void *p) {
      delete ((::TIndexTable*)p);
   }
   static void deleteArray_TIndexTable(void *p) {
      delete [] ((::TIndexTable*)p);
   }
   static void destruct_TIndexTable(void *p) {
      typedef ::TIndexTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TIndexTable(TBuffer &buf, void *obj) {
      ((::TIndexTable*)obj)->::TIndexTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TIndexTable

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TIndexTablecLcLiterator(void *p) {
      delete ((::TIndexTable::iterator*)p);
   }
   static void deleteArray_TIndexTablecLcLiterator(void *p) {
      delete [] ((::TIndexTable::iterator*)p);
   }
   static void destruct_TIndexTablecLcLiterator(void *p) {
      typedef ::TIndexTable::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TIndexTable::iterator

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TChair(void *p) {
      delete ((::TChair*)p);
   }
   static void deleteArray_TChair(void *p) {
      delete [] ((::TChair*)p);
   }
   static void destruct_TChair(void *p) {
      typedef ::TChair current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TChair

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TTableSorter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTableSorter.
      TClass *R__cl = ::TTableSorter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", (void*)&fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSortIndex", &fSortIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastFound", &fLastFound);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstRow", &fFirstRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumberOfRows", &fNumberOfRows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColName", &fColName);
      R__insp.InspectMember(fColName, "fColName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColOffset", &fColOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColSize", &fColSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndexArray", &fIndexArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColDimensions", &fColDimensions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fsimpleArray", &fsimpleArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParentTable", &fParentTable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSearchMethod", &fSearchMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompareMethod", &fCompareMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColType", &fColType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParentRowSize", &fParentRowSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstParentRow", &fFirstParentRow);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTableSorter(void *p) {
      return  p ? new(p) ::TTableSorter : new ::TTableSorter;
   }
   static void *newArray_TTableSorter(Long_t nElements, void *p) {
      return p ? new(p) ::TTableSorter[nElements] : new ::TTableSorter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTableSorter(void *p) {
      delete ((::TTableSorter*)p);
   }
   static void deleteArray_TTableSorter(void *p) {
      delete [] ((::TTableSorter*)p);
   }
   static void destruct_TTableSorter(void *p) {
      typedef ::TTableSorter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTableSorter(TBuffer &buf, void *obj) {
      ((::TTableSorter*)obj)->::TTableSorter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTableSorter

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTableDescriptor(void *p) {
      return  p ? new(p) ::TTableDescriptor : new ::TTableDescriptor;
   }
   static void *newArray_TTableDescriptor(Long_t nElements, void *p) {
      return p ? new(p) ::TTableDescriptor[nElements] : new ::TTableDescriptor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTableDescriptor(void *p) {
      delete ((::TTableDescriptor*)p);
   }
   static void deleteArray_TTableDescriptor(void *p) {
      delete [] ((::TTableDescriptor*)p);
   }
   static void destruct_TTableDescriptor(void *p) {
      typedef ::TTableDescriptor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTableDescriptor(TBuffer &buf, void *obj) {
      ((::TTableDescriptor*)obj)->::TTableDescriptor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTableDescriptor

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::tableDescriptor_st*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColumnName[32]", sobj->fColumnName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndexArray[3]", sobj->fIndexArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &sobj->fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &sobj->fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeSize", &sobj->fTypeSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDimensions", &sobj->fDimensions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &sobj->fType);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_tableDescriptor_st(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::tableDescriptor_st : new ::tableDescriptor_st;
   }
   static void *newArray_tableDescriptor_st(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::tableDescriptor_st[nElements] : new ::tableDescriptor_st[nElements];
   }
   // Wrapper around operator delete
   static void delete_tableDescriptor_st(void *p) {
      delete ((::tableDescriptor_st*)p);
   }
   static void deleteArray_tableDescriptor_st(void *p) {
      delete [] ((::tableDescriptor_st*)p);
   }
   static void destruct_tableDescriptor_st(void *p) {
      typedef ::tableDescriptor_st current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::tableDescriptor_st

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

   TChair::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TColumnView(void *p) {
      return  p ? new(p) ::TColumnView : new ::TColumnView;
   }
   static void *newArray_TColumnView(Long_t nElements, void *p) {
      return p ? new(p) ::TColumnView[nElements] : new ::TColumnView[nElements];
   }
   // Wrapper around operator delete
   static void delete_TColumnView(void *p) {
      delete ((::TColumnView*)p);
   }
   static void deleteArray_TColumnView(void *p) {
      delete [] ((::TColumnView*)p);
   }
   static void destruct_TColumnView(void *p) {
      typedef ::TColumnView current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TColumnView(TBuffer &buf, void *obj) {
      ((::TColumnView*)obj)->::TColumnView::Streamer(buf);
   }
} // end of namespace ROOT for class ::TColumnView

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTableMap(void *p) {
      return  p ? new(p) ::TTableMap : new ::TTableMap;
   }
   static void *newArray_TTableMap(Long_t nElements, void *p) {
      return p ? new(p) ::TTableMap[nElements] : new ::TTableMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTableMap(void *p) {
      delete ((::TTableMap*)p);
   }
   static void deleteArray_TTableMap(void *p) {
      delete [] ((::TTableMap*)p);
   }
   static void destruct_TTableMap(void *p) {
      typedef ::TTableMap current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTableMap(TBuffer &buf, void *obj) {
      ((::TTableMap*)obj)->::TTableMap::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTableMap

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTablePadView3D(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTablePadView3D : new ::TTablePadView3D;
   }
   static void *newArray_TTablePadView3D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTablePadView3D[nElements] : new ::TTablePadView3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTablePadView3D(void *p) {
      delete ((::TTablePadView3D*)p);
   }
   static void deleteArray_TTablePadView3D(void *p) {
      delete [] ((::TTablePadView3D*)p);
   }
   static void destruct_TTablePadView3D(void *p) {
      typedef ::TTablePadView3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTablePadView3D

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TResponseTable(void *p) {
      return  p ? new(p) ::TResponseTable : new ::TResponseTable;
   }
   static void *newArray_TResponseTable(Long_t nElements, void *p) {
      return p ? new(p) ::TResponseTable[nElements] : new ::TResponseTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TResponseTable(void *p) {
      delete ((::TResponseTable*)p);
   }
   static void deleteArray_TResponseTable(void *p) {
      delete [] ((::TResponseTable*)p);
   }
   static void destruct_TResponseTable(void *p) {
      typedef ::TResponseTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TResponseTable(TBuffer &buf, void *obj) {
      ((::TResponseTable*)obj)->::TResponseTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TResponseTable

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPoints3D(void *p) {
      return  p ? new(p) ::TPoints3D : new ::TPoints3D;
   }
   static void *newArray_TPoints3D(Long_t nElements, void *p) {
      return p ? new(p) ::TPoints3D[nElements] : new ::TPoints3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPoints3D(void *p) {
      delete ((::TPoints3D*)p);
   }
   static void deleteArray_TPoints3D(void *p) {
      delete [] ((::TPoints3D*)p);
   }
   static void destruct_TPoints3D(void *p) {
      typedef ::TPoints3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPoints3D

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

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

//______________________________________________________________________________
void TPolyLineShape::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPolyLineShape.
      TClass *R__cl = ::TPolyLineShape::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointFlag", &fPointFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineFlag", &fLineFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShapeType", &fShapeType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConnection", &fConnection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPoints", &fPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidthFactor", &fWidthFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasDrawn", &fHasDrawn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmooth", &fSmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSizeX3D", &fSizeX3D);
      TShape::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPolyLineShape(void *p) {
      return  p ? new(p) ::TPolyLineShape : new ::TPolyLineShape;
   }
   static void *newArray_TPolyLineShape(Long_t nElements, void *p) {
      return p ? new(p) ::TPolyLineShape[nElements] : new ::TPolyLineShape[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPolyLineShape(void *p) {
      delete ((::TPolyLineShape*)p);
   }
   static void deleteArray_TPolyLineShape(void *p) {
      delete [] ((::TPolyLineShape*)p);
   }
   static void destruct_TPolyLineShape(void *p) {
      typedef ::TPolyLineShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPolyLineShape

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

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

//______________________________________________________________________________
void TVolume::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVolume.
      TClass *R__cl = ::TVolume::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListOfShapes", &fListOfShapes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisibility", &fVisibility);
      TObjectSet::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVolume(void *p) {
      return  p ? new(p) ::TVolume : new ::TVolume;
   }
   static void *newArray_TVolume(Long_t nElements, void *p) {
      return p ? new(p) ::TVolume[nElements] : new ::TVolume[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVolume(void *p) {
      delete ((::TVolume*)p);
   }
   static void deleteArray_TVolume(void *p) {
      delete [] ((::TVolume*)p);
   }
   static void destruct_TVolume(void *p) {
      typedef ::TVolume current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVolume

//______________________________________________________________________________
void TVolumePosition::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVolumePosition.
      TClass *R__cl = ::TVolumePosition::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX[3]", fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNode", &fNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fId", &fId);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVolumePosition(void *p) {
      return  p ? new(p) ::TVolumePosition : new ::TVolumePosition;
   }
   static void *newArray_TVolumePosition(Long_t nElements, void *p) {
      return p ? new(p) ::TVolumePosition[nElements] : new ::TVolumePosition[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVolumePosition(void *p) {
      delete ((::TVolumePosition*)p);
   }
   static void deleteArray_TVolumePosition(void *p) {
      delete [] ((::TVolumePosition*)p);
   }
   static void destruct_TVolumePosition(void *p) {
      typedef ::TVolumePosition current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TVolumePosition(TBuffer &buf, void *obj) {
      ((::TVolumePosition*)obj)->::TVolumePosition::Streamer(buf);
   }
} // end of namespace ROOT for class ::TVolumePosition

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVolumeView(void *p) {
      return  p ? new(p) ::TVolumeView : new ::TVolumeView;
   }
   static void *newArray_TVolumeView(Long_t nElements, void *p) {
      return p ? new(p) ::TVolumeView[nElements] : new ::TVolumeView[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVolumeView(void *p) {
      delete ((::TVolumeView*)p);
   }
   static void deleteArray_TVolumeView(void *p) {
      delete [] ((::TVolumeView*)p);
   }
   static void destruct_TVolumeView(void *p) {
      typedef ::TVolumeView current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVolumeView

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

   TDataSetIter::Streamer(R__b);
}

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

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

//______________________________________________________________________________
void TPointsArray3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPointsArray3D.
      TClass *R__cl = ::TPointsArray3D::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(), "*fP", &fP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGLList", &fGLList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPoint", &fLastPoint);
      TPoints3DABC::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPointsArray3D(void *p) {
      return  p ? new(p) ::TPointsArray3D : new ::TPointsArray3D;
   }
   static void *newArray_TPointsArray3D(Long_t nElements, void *p) {
      return p ? new(p) ::TPointsArray3D[nElements] : new ::TPointsArray3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPointsArray3D(void *p) {
      delete ((::TPointsArray3D*)p);
   }
   static void deleteArray_TPointsArray3D(void *p) {
      delete [] ((::TPointsArray3D*)p);
   }
   static void destruct_TPointsArray3D(void *p) {
      typedef ::TPointsArray3D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPointsArray3D(TBuffer &buf, void *obj) {
      ((::TPointsArray3D*)obj)->::TPointsArray3D::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPointsArray3D

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

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

//______________________________________________________________________________
void TTablePoints::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTablePoints.
      TClass *R__cl = ::TTablePoints::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTableSorter", &fTableSorter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKey", &fKey);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstRow", &fFirstRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRows", &fRows);
      TPoints3DABC::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TTablePoints(void *p) {
      delete ((::TTablePoints*)p);
   }
   static void deleteArray_TTablePoints(void *p) {
      delete [] ((::TTablePoints*)p);
   }
   static void destruct_TTablePoints(void *p) {
      typedef ::TTablePoints current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTablePoints

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTable3Points(void *p) {
      return  p ? new(p) ::TTable3Points : new ::TTable3Points;
   }
   static void *newArray_TTable3Points(Long_t nElements, void *p) {
      return p ? new(p) ::TTable3Points[nElements] : new ::TTable3Points[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTable3Points(void *p) {
      delete ((::TTable3Points*)p);
   }
   static void deleteArray_TTable3Points(void *p) {
      delete [] ((::TTable3Points*)p);
   }
   static void destruct_TTable3Points(void *p) {
      typedef ::TTable3Points current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTable3Points

/********************************************************
* misc/table/src/G__Table.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__Table();

extern "C" void G__set_cpp_environmentG__Table() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("tableDescriptor.h");
  G__add_compiledheader("TCernLib.h");
  G__add_compiledheader("TChair.h");
  G__add_compiledheader("TColumnView.h");
  G__add_compiledheader("TDataSet.h");
  G__add_compiledheader("TDataSetIter.h");
  G__add_compiledheader("TDsKey.h");
  G__add_compiledheader("TFileIter.h");
  G__add_compiledheader("TFileSet.h");
  G__add_compiledheader("TGenericTable.h");
  G__add_compiledheader("TIndexTable.h");
  G__add_compiledheader("TObjectSet.h");
  G__add_compiledheader("TPoints3D.h");
  G__add_compiledheader("TPointsArray3D.h");
  G__add_compiledheader("TPolyLineShape.h");
  G__add_compiledheader("TResponseTable.h");
  G__add_compiledheader("TTable3Points.h");
  G__add_compiledheader("TTableDescriptor.h");
  G__add_compiledheader("TTable.h");
  G__add_compiledheader("TTableIter.h");
  G__add_compiledheader("TTableMap.h");
  G__add_compiledheader("TTablePadView3D.h");
  G__add_compiledheader("TTablePoints.h");
  G__add_compiledheader("TTableSorter.h");
  G__add_compiledheader("Ttypes.h");
  G__add_compiledheader("TVolume.h");
  G__add_compiledheader("TVolumePosition.h");
  G__add_compiledheader("TVolumeView.h");
  G__add_compiledheader("TVolumeViewIter.h");
  G__cpp_reset_tagtableG__Table();
}
#include <new>
extern "C" int G__cpp_dllrevG__Table() { return(30051515); }

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

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

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

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

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

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


/* TCL */
static int G__G__Table_101_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) TCL::ucopy((const int*) G__int(libp->para[0]), (int*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::ucopy((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::ucopy((float*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::ucopy((double*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::ucopy((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TCL::ucopy((const void**) G__int(libp->para[0]), (void**) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vzero((float*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vzero((double*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TCL::vzero((void**) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vadd((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vadd((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vadd((float*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vadd((double*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TCL::vdot((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TCL::vdot((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vsub((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vsub((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vsub((float*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vsub((double*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vcopyn((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vcopyn((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vscale((float*) G__int(libp->para[0]), (float) G__double(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vscale((double*) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::vlinco((float*) G__int(libp->para[0]), (float) G__double(libp->para[1])
, (float*) G__int(libp->para[2]), (float) G__double(libp->para[3])
, (float*) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::vlinco((double*) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double*) G__int(libp->para[2]), (double) G__double(libp->para[3])
, (double*) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 70, (long) TCL::vmatl((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 70, (long) TCL::vmatl((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 70, (long) TCL::vmatl((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 68, (long) TCL::vmatl((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 68, (long) TCL::vmatl((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 68, (long) TCL::vmatl((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 70, (long) TCL::vmatr((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 70, (long) TCL::vmatr((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 70, (long) TCL::vmatr((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 68, (long) TCL::vmatr((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 68, (long) TCL::vmatr((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 68, (long) TCL::vmatr((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmad_0_(
(int) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (float*) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (int) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmad((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmad1((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmad2((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmad3((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmpy((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmpy1((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmpy2((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmpy3((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmub((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmub1((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmub2((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmub3((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmlrt_0_((int) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (float*) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmlrt((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxmltr((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::mxtrp((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmad_0_(
(int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (int) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmad((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmad1((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmad2((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmad3((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmpy((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmpy1((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmpy2((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmpy3((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmub((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmub1((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmub2((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmub3((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmlrt_0_((int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmlrt((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxmltr((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::mxtrp((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::traat((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::tral((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::tralt((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::tras((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trasat((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trasat((double*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trata((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trats((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::tratsa((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trchlu((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trchul((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trinv((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trla((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trlta((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trpck((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trqsq((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trsa((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trsinv((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trsmlu((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trsmul((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trupck((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) TCL::trsat((float*) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 70, (long) TCL::trsequ((float*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 70, (long) TCL::trsequ((float*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (float*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 70, (long) TCL::trsequ((float*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 70, (long) TCL::trsequ((float*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::traat((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::tral((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::tralt((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::tras((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trasat((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trata((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trats((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::tratsa((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trchlu((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trchul((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trinv((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trla((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trlta((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trpck((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trqsq((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trsa((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trsinv((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trsmlu((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trsmul((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trupck((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) TCL::trsat((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_101_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 68, (long) TCL::trsequ((double*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 68, (long) TCL::trsequ((double*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (double*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 68, (long) TCL::trsequ((double*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 68, (long) TCL::trsequ((double*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

static int G__G__Table_102_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TTable*) G__getstructoffset())->AppendRows((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TTable*) G__getstructoffset())->AsString((void*) G__int(libp->para[0]), (TTable::EColumnType) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(ostream*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_102_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TTable*) G__getstructoffset())->CopyRows((TTable*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (Long_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TTable*) G__getstructoffset())->CopyRows((TTable*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (Long_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TTable*) G__getstructoffset())->CopyRows((TTable*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTable*) G__getstructoffset())->CopyRows((TTable*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTable*) G__getstructoffset())->CopyRows((TTable*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Table_102_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TTable*) G__getstructoffset())->GetNRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TTable*) G__getstructoffset())->GetRowSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TTable*) G__getstructoffset())->GetTableSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Table_102_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 108, (long) ((TTable*) G__getstructoffset())->InsertRows((void*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 108, (long) ((TTable*) G__getstructoffset())->InsertRows((void*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_102_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTable::New((const Char_t*) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TTable*) G__getstructoffset())->MakeExpression((const Char_t**) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->Print((Char_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2]), (const Char_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Table_102_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TTable*) G__getstructoffset())->ReAllocate());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Table_102_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->GetColumnName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((const TTable*) G__getstructoffset())->GetIndexArray((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_102_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTable*) G__getstructoffset())->GetOffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_102_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTable*) G__getstructoffset())->GetColumnSize((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_102_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTable*) G__getstructoffset())->GetTypeSize((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_102_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTable*) G__getstructoffset())->GetDimensions((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Table_102_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTable*) G__getstructoffset())->GetColumnComment((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_102_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTable::GetTypeName((TTable::EColumnType) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__G__Table_138_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TDataSetIter*) G__getstructoffset())->operator()((TDataSet::EDataSetPass) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TDataSetIter*) G__getstructoffset())->operator()());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Table_138_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((UInt_t) G__int(libp->para[0]), (TDataSet::EBitOpt) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_138_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((const Char_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (TDataSet::EBitOpt) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((const Char_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((const Char_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_138_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((TDataSet*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (TDataSet::EBitOpt) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((TDataSet*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TDataSetIter*) G__getstructoffset())->Flag((TDataSet*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Table_138_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TDataSetIter*) G__getstructoffset())->Path((const Char_t*) G__int(libp->para[0]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_138_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TDataSetIter*) G__getstructoffset())->Path();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Table_138_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TDataSetIter*) G__getstructoffset())->Next((TDataSet::EDataSetPass) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TDataSetIter*) G__getstructoffset())->Next());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_138_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDataSetIter*) G__getstructoffset())->Notify((TDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

static int G__G__Table_139_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const TDataSet*) G__getstructoffset())->FindByName((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) ((const TDataSet*) G__getstructoffset())->FindByName((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TDataSet*) G__getstructoffset())->FindByName((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_139_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const TDataSet*) G__getstructoffset())->FindByTitle((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) ((const TDataSet*) G__getstructoffset())->FindByTitle((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TDataSet*) G__getstructoffset())->FindByTitle((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__Table_139_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TDataSet*) G__getstructoffset())->HasData());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_139_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TDataSet*) G__getstructoffset())->Path();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_139_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TDataSet*) G__getstructoffset())->Pass((TDataSet::EDataSetPass (*)(TDataSet*)) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TDataSet*) G__getstructoffset())->Pass((TDataSet::EDataSetPass (*)(TDataSet*)) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Table_144_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableDescriptor*) G__getstructoffset())->AddAt(*(tableDescriptor_st*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_144_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TTableDescriptor*) G__getstructoffset())->CreateLeafList();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_144_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableDescriptor*) G__getstructoffset())->LearnTable((TTable*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_144_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTableDescriptor*) G__getstructoffset())->ColumnName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_144_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((const TTableDescriptor*) G__getstructoffset())->IndexArray((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_144_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTableDescriptor*) G__getstructoffset())->Offset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_144_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTableDescriptor*) G__getstructoffset())->ColumnSize((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_144_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTableDescriptor*) G__getstructoffset())->TypeSize((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_144_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTableDescriptor*) G__getstructoffset())->Dimensions((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Table_144_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableDescriptor*) G__getstructoffset())->SetColumnType((TTable::EColumnType) 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__Table_144_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableDescriptor*) G__getstructoffset())->UpdateOffsets((TTableDescriptor*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Table_146_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTable::iterator* pobj;
         TTable::iterator xobj = ((TTableMap*) G__getstructoffset())->Begin();
         pobj = new TTable::iterator(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__Table_146_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTable::iterator* pobj;
         const TTable::iterator xobj = ((const TTableMap*) G__getstructoffset())->Begin();
         pobj = new TTable::iterator(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__Table_146_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTable::iterator* pobj;
         TTable::iterator xobj = ((TTableMap*) G__getstructoffset())->End();
         pobj = new TTable::iterator(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__Table_146_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTable::iterator* pobj;
         const TTable::iterator xobj = ((const TTableMap*) G__getstructoffset())->End();
         pobj = new TTable::iterator(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__Table_146_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTableMap::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Table_150_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator=(*(TTable::iterator*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator++();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator--();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTable::iterator* pobj;
         TTable::iterator xobj = ((TTable::iterator*) G__getstructoffset())->operator+((Int_t) G__int(libp->para[0]));
         pobj = new TTable::iterator(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__Table_150_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTable::iterator* pobj;
         TTable::iterator xobj = ((TTable::iterator*) G__getstructoffset())->operator-((Int_t) G__int(libp->para[0]));
         pobj = new TTable::iterator(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__Table_150_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator+=((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable::iterator*) G__getstructoffset())->operator-=((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TTable::iterator*) G__getstructoffset())->rowPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TTable::iterator*) G__getstructoffset())->operator void*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTable::iterator*) G__getstructoffset())->operator-(*(TTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TTable::iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTable::iterator*) G__getstructoffset())->operator==(*(TTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTable::iterator*) G__getstructoffset())->operator!=(*(TTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTable& obj = ((const TTable::iterator*) G__getstructoffset())->Table();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_150_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Long_t& obj = ((const TTable::iterator*) G__getstructoffset())->RowSize();
         result7->ref = (long) (&obj);
         G__letint(result7, 'l', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

static int G__G__Table_155_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TChair*) G__getstructoffset())->GetNRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_155_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TChair*) G__getstructoffset())->GetRowSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_155_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TChair*) G__getstructoffset())->GetTableSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Table_155_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TChair*) G__getstructoffset())->MakeExpression((const Char_t**) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_155_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TChair*) G__getstructoffset())->Print((Char_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_155_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 67, (long) ((const TChair*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2]), (const Char_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 67, (long) ((const TChair*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 67, (long) ((const TChair*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 67, (long) ((const TChair*) G__getstructoffset())->Print((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_155_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TChair*) G__getstructoffset())->ReAllocate());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__G__Table_192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         TString* pobj;
         TString xobj = TFileIter::MapName((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TString* pobj;
         TString xobj = TFileIter::MapName((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TString* pobj;
         TString xobj = TFileIter::MapName((const char*) G__int(libp->para[0]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Table_192_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFileIter*) G__getstructoffset())->operator const ::TFile*());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Table_192_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFileIter*) G__getstructoffset())->operator!=((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Table_194_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGenericTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGenericTable(
(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) TGenericTable(
(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__TableLN_TGenericTable));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_194_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGenericTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGenericTable(*(TTableDescriptor*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGenericTable(*(TTableDescriptor*) libp->para[0].ref, (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__TableLN_TGenericTable));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_194_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((TGenericTable*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_194_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((const TGenericTable*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_194_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TGenericTable::iterator* pobj;
         TGenericTable::iterator xobj = ((TGenericTable*) G__getstructoffset())->begin();
         pobj = new TGenericTable::iterator(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__Table_194_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGenericTable::iterator* pobj;
         const TGenericTable::iterator xobj = ((const TGenericTable*) G__getstructoffset())->begin();
         pobj = new TGenericTable::iterator(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__Table_194_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TGenericTable::iterator* pobj;
         TGenericTable::iterator xobj = ((TGenericTable*) G__getstructoffset())->end();
         pobj = new TGenericTable::iterator(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__Table_194_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGenericTable::iterator* pobj;
         const TGenericTable::iterator xobj = ((const TGenericTable*) G__getstructoffset())->end();
         pobj = new TGenericTable::iterator(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__Table_194_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGenericTable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__Table_195_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGenericTable::iterator& obj = ((TGenericTable::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_195_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGenericTable::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_195_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGenericTable::iterator& obj = ((TGenericTable::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_195_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGenericTable::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_195_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGenericTable::iterator*) G__getstructoffset())->operator-(*(TGenericTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_195_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGenericTable::iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_195_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGenericTable::iterator*) G__getstructoffset())->operator==(*(TGenericTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_195_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGenericTable::iterator*) G__getstructoffset())->operator!=(*(TGenericTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__G__Table_196_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 73, (long) ((TIndexTable*) G__getstructoffset())->GetTable((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 73, (long) ((TIndexTable*) G__getstructoffset())->GetTable());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Table_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TIndexTable::iterator* pobj;
         TIndexTable::iterator xobj = ((TIndexTable*) G__getstructoffset())->begin();
         pobj = new TIndexTable::iterator(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__Table_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TIndexTable::iterator* pobj;
         const TIndexTable::iterator xobj = ((const TIndexTable*) G__getstructoffset())->begin();
         pobj = new TIndexTable::iterator(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__Table_196_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TIndexTable::iterator* pobj;
         TIndexTable::iterator xobj = ((TIndexTable*) G__getstructoffset())->end();
         pobj = new TIndexTable::iterator(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__Table_196_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TIndexTable::iterator* pobj;
         const TIndexTable::iterator xobj = ((const TIndexTable*) G__getstructoffset())->end();
         pobj = new TIndexTable::iterator(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__Table_196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TIndexTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TIndexTable[n];
     } else {
       p = new((void*) gvp) TIndexTable[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TIndexTable;
     } else {
       p = new((void*) gvp) TIndexTable;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TIndexTable));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Table_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TIndexTable::iterator& obj = ((TIndexTable::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TIndexTable::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TIndexTable::iterator& obj = ((TIndexTable::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TIndexTable::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TIndexTable::iterator*) G__getstructoffset())->operator-(*(TIndexTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TIndexTable::iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TIndexTable::iterator*) G__getstructoffset())->operator int());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TIndexTable::iterator*) G__getstructoffset())->operator==(*(TIndexTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TIndexTable::iterator*) G__getstructoffset())->operator!=(*(TIndexTable::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Table_208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPolyLineShape*) G__getstructoffset())->Paint3d((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_208_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp3 { Double_t a[1][3]; }* G__Ap3 = (struct G__aRyp3*) G__int(libp->para[3]);
      G__letint(result7, 68, (long) TPolyLineShape::Gyrot((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), G__Ap3->a));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Table_208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 102, (double) TPolyLineShape::Product((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 102, (double) TPolyLineShape::Product((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) TPolyLineShape::Product((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) TPolyLineShape::Product((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((TPolyLineShape*) G__getstructoffset())->SetColorAttribute((Color_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_208_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TPolyLineShape*) G__getstructoffset())->SetSizeAttribute((Size_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_208_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPolyLineShape*) G__getstructoffset())->SetShape((TShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Table_208_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((TPolyLineShape*) G__getstructoffset())->SetStyleAttribute((Style_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Table_209_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TResponseTable*) G__getstructoffset())->SetResponse((int) G__int(libp->para[0]), (int*) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_209_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TResponseTable::FindResponseLocation(*(TTableDescriptor*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Table_211_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableSorter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTableSorter(
*(TTable*) libp->para[0].ref, (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TTableSorter(
*(TTable*) libp->para[0].ref, (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_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 TTableSorter(
*(TTable*) libp->para[0].ref, (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TTableSorter(
*(TTable*) libp->para[0].ref, (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTableSorter(
*(TTable*) libp->para[0].ref, (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TTableSorter(
*(TTable*) libp->para[0].ref, (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) 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__TableLN_TTableSorter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_211_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableSorter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTableSorter(
(TTable*) G__int(libp->para[0]), (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TTableSorter(
(TTable*) G__int(libp->para[0]), (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_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 TTableSorter(
(TTable*) G__int(libp->para[0]), (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TTableSorter(
(TTable*) G__int(libp->para[0]), (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTableSorter(
(TTable*) G__int(libp->para[0]), (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TTableSorter(
(TTable*) G__int(libp->para[0]), (SEARCHMETHOD) G__int(libp->para[1])
, (COMPAREMETHOD) 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__TableLN_TTableSorter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TTablePoints */
static int G__G__Table_213_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TTablePoints*) G__getstructoffset())->GetTable());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

static int G__G__Table_214_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TTable3Points*) G__getstructoffset())->GetAnyPoint((Int_t) G__int(libp->para[0]), (TTable3Points::EPointDirection) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTable3Points::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTable3Points::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTable3Points::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTable3Points::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTable3Points*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTable3Points::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTable3Points::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTable3Points::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_214_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTable3Points::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Table_214_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTable3Points* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTable3Points(*(TTable3Points*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTable3Points));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTable3Points G__TTTable3Points;
static int G__G__Table_214_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[] (TTable3Points*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTable3Points*) (soff+(sizeof(TTable3Points)*i)))->~G__TTTable3Points();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTable3Points*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTable3Points*) (soff))->~G__TTTable3Points();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTableIter */
static int G__G__Table_216_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTableIter((TTableSorter*) G__int(libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
   } else {
     p = new((void*) gvp) TTableIter((TTableSorter*) G__int(libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTableIter((TTableSorter*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
   } else {
     p = new((void*) gvp) TTableIter((TTableSorter*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTableIter((TTableSorter*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
   } else {
     p = new((void*) gvp) TTableIter((TTableSorter*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTableIter((TTableSorter*) G__int(libp->para[0]), *(Long_t*) G__Longref(&libp->para[1]));
   } else {
     p = new((void*) gvp) TTableIter((TTableSorter*) G__int(libp->para[0]), *(Long_t*) G__Longref(&libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTableIter((TTableSorter*) G__int(libp->para[0]), *(Short_t*) G__Shortref(&libp->para[1]));
   } else {
     p = new((void*) gvp) TTableIter((TTableSorter*) G__int(libp->para[0]), *(Short_t*) G__Shortref(&libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->CountKey(*(Float_t*) G__Floatref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->CountKey(*(Long_t*) G__Longref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->CountKey(*(Int_t*) G__Intref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->CountKey(*(Short_t*) G__Shortref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->CountKey(*(Double_t*) G__Doubleref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTableIter*) G__getstructoffset())->GetNRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->Next((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->Reset((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->Reset());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->operator()());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTableIter*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTableIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTableIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTableIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTableIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTableIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTableIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTableIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTableIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_216_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTableIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTableIter G__TTTableIter;
static int G__G__Table_216_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTableIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTableIter*) (soff+(sizeof(TTableIter)*i)))->~G__TTTableIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTableIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTableIter*) (soff))->~G__TTTableIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTablePadView3D */
static int G__G__Table_219_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTablePadView3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTablePadView3D[n];
     } else {
       p = new((void*) gvp) TTablePadView3D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTablePadView3D;
     } else {
       p = new((void*) gvp) TTablePadView3D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTablePadView3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTablePadView3D((TVirtualPad*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TTablePadView3D((TVirtualPad*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->ExecuteEvent((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTablePadView3D*) G__getstructoffset())->GetPad());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->Paint((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTablePadView3D*) G__getstructoffset())->Paint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->Size((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__Table_219_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->PaintBeginModel((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTablePadView3D*) G__getstructoffset())->PaintBeginModel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->PaintEnd((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTablePadView3D*) G__getstructoffset())->PaintEnd();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->PaintScene((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTablePadView3D*) G__getstructoffset())->PaintScene();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTablePadView3D*) G__getstructoffset())->PaintPolyMarker((TPolyMarker3D*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->PaintPolyMarker((TPolyMarker3D*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTablePadView3D*) G__getstructoffset())->PaintPolyLine((TPolyLine3D*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->PaintPolyLine((TPolyLine3D*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTablePadView3D*) G__getstructoffset())->PaintPoints3D((TPoints3DABC*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->PaintPoints3D((TPoints3DABC*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->PushMatrix();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->PopMatrix();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTablePadView3D*) G__getstructoffset())->SetAttNode((TNode*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->SetAttNode((TNode*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TTablePadView3D*) G__getstructoffset())->SetLineAttr((Color_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TTablePadView3D*) G__getstructoffset())->SetLineAttr((Color_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__Table_219_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->SetPad((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTablePadView3D*) G__getstructoffset())->SetPad();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTablePadView3D*) G__getstructoffset())->UpdateNodeMatrix((TNode*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTablePadView3D*) G__getstructoffset())->UpdateNodeMatrix((TNode*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TTablePadView3D*) G__getstructoffset())->UpdatePosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TRotMatrix*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TTablePadView3D*) G__getstructoffset())->UpdatePosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TRotMatrix*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->UpdateView();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TTablePadView3D*) G__getstructoffset())->GetRange((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->SetRange((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TTablePadView3D*) G__getstructoffset())->GetShift((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->SetShift((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TTablePadView3D*) G__getstructoffset())->GetAngles((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->SetAngles((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TTablePadView3D*) G__getstructoffset())->GetAnglesFactors((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->SetAnglesFactors((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TTablePadView3D*) G__getstructoffset())->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_219_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTablePadView3D*) G__getstructoffset())->SetScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Table_219_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTablePadView3D* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTablePadView3D(*(TTablePadView3D*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTablePadView3D G__TTTablePadView3D;
static int G__G__Table_219_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTablePadView3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTablePadView3D*) (soff+(sizeof(TTablePadView3D)*i)))->~G__TTTablePadView3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTablePadView3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTablePadView3D*) (soff))->~G__TTTablePadView3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Table_219_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTablePadView3D* dest = (TTablePadView3D*) G__getstructoffset();
   *dest = *(TTablePadView3D*) libp->para[0].ref;
   const TTablePadView3D& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVolumePosition */
static int G__G__Table_220_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumePosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumePosition(
(TVolume*) 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])
, (TRotMatrix*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TVolumePosition(
(TVolume*) 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])
, (TRotMatrix*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumePosition(
(TVolume*) 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]));
     } else {
       p = new((void*) gvp) TVolumePosition(
(TVolume*) 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]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumePosition(
(TVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TVolumePosition(
(TVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumePosition((TVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TVolumePosition((TVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumePosition((TVolume*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TVolumePosition((TVolume*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TVolumePosition[n];
       } else {
         p = new((void*) gvp) TVolumePosition[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TVolumePosition;
       } else {
         p = new((void*) gvp) TVolumePosition;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumePosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumePosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolumePosition(
(TVolume*) 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])
, (const char*) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TVolumePosition(
(TVolume*) 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])
, (const char*) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumePosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumePosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolumePosition((TVolumePosition*) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVolumePosition((TVolumePosition*) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumePosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumePosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolumePosition(*(TVolumePosition*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVolumePosition(*(TVolumePosition*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumePosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Errmx2Local((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Errmx2Local((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Errmx2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Errmx2Master((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Cormx2Local((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Cormx2Local((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Cormx2Master((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Cormx2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Master2Local((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Master2Local((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Master2Local((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Master2Local((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->DefineSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolumePosition*) G__getstructoffset())->GetNode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVolumePosition*) G__getstructoffset())->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolumePosition*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVolumePosition*) G__getstructoffset())->GetVisibility());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TVolumePosition*) G__getstructoffset())->GetX((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TVolumePosition*) G__getstructoffset())->GetX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->GetXYZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVolumePosition*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVolumePosition*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TVolumePosition*) G__getstructoffset())->GetId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVolumePosition*) G__getstructoffset())->IsMatrixOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TVolumePosition*) G__getstructoffset())->SetMatrixOwner((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TVolumePosition*) G__getstructoffset())->SetMatrixOwner());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVolumePosition*) G__getstructoffset())->Is3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Local2Master((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 68, (long) ((const TVolumePosition*) G__getstructoffset())->Local2Master((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 70, (long) ((const TVolumePosition*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVolumePosition& obj = ((TVolumePosition*) G__getstructoffset())->Mult(*(TVolumePosition*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolumePosition*) G__getstructoffset())->UpdatePosition((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumePosition*) G__getstructoffset())->UpdatePosition();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->Reset((TVolume*) 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])
, (TRotMatrix*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->Reset((TVolume*) 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])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->Reset((TVolume*) G__int(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) ((TVolumePosition*) G__getstructoffset())->Reset((TVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->Reset((TVolume*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVolumePosition*) G__getstructoffset())->Reset());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->SetLineAttributes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolumePosition*) G__getstructoffset())->SetMatrix((TRotMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumePosition*) G__getstructoffset())->SetMatrix();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->SetNode((TVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVolumePosition*) G__getstructoffset())->SetPosition((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:
      ((TVolumePosition*) G__getstructoffset())->SetPosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVolumePosition*) G__getstructoffset())->SetPosition((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumePosition*) G__getstructoffset())->SetPosition();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolumePosition*) G__getstructoffset())->SetVisibility((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumePosition*) G__getstructoffset())->SetVisibility();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->SetX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->SetY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->SetZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolumePosition*) G__getstructoffset())->SetXYZ((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumePosition*) G__getstructoffset())->SetXYZ();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->SetId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVolumePosition& obj = ((TVolumePosition*) G__getstructoffset())->operator=(*(TVolumePosition*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVolumePosition::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumePosition::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVolumePosition::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVolumePosition::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumePosition*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumePosition::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolumePosition::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumePosition::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_220_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolumePosition::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVolumePosition G__TTVolumePosition;
static int G__G__Table_220_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVolumePosition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVolumePosition*) (soff+(sizeof(TVolumePosition)*i)))->~G__TTVolumePosition();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVolumePosition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVolumePosition*) (soff))->~G__TTVolumePosition();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVolume */
static int G__G__Table_221_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolume* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolume[n];
     } else {
       p = new((void*) gvp) TVolume[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolume;
     } else {
       p = new((void*) gvp) TVolume;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolume* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolume* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TShape*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TShape*) 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 TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TShape*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TVolume(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TShape*) 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__TableLN_TVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolume* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolume(*(TNode*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVolume(*(TNode*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add(
(TVolume*) 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])
, (TRotMatrix*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) 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])
, (TRotMatrix*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) 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])
, (TRotMatrix*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) 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])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) G__int(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) ((TVolume*) G__getstructoffset())->Add((TVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add(
(TVolume*) 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])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) 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])
, (const char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->Add((TVolume*) 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])
, (const char*) G__int(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolume::MapStNode2GEANTVis((TVolume::ENodeSEEN) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolume::MapGEANT2StNodeVis((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVolume*) G__getstructoffset())->Add((TShape*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVolume*) G__getstructoffset())->Add((TShape*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->CreateTNode((TVolumePosition*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->CreateTNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolume*) G__getstructoffset())->DeletePosition((TVolumePosition*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolume*) G__getstructoffset())->DrawOnly((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolume*) G__getstructoffset())->DrawOnly();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVolume::GetIdentity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVolume*) G__getstructoffset())->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolume*) G__getstructoffset())->GetShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolume*) G__getstructoffset())->GetListOfShapes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolume*) G__getstructoffset())->GetLocalRange((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVolume*) G__getstructoffset())->GetVisibility());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolume*) G__getstructoffset())->GetListOfPositions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolume*) G__getstructoffset())->ImportShapeAttributes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVolume*) G__getstructoffset())->Is3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolume*) G__getstructoffset())->Nodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolume*) G__getstructoffset())->PaintShape((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolume*) G__getstructoffset())->PaintShape();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolume*) G__getstructoffset())->SetVisibility((TVolume::ENodeSEEN) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolume*) G__getstructoffset())->SetVisibility();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVolume::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolume::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVolume::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVolume::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolume*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolume::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolume::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolume::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_221_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolume::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Table_221_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TVolume* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TVolume(*(TVolume*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVolume G__TTVolume;
static int G__G__Table_221_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVolume*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVolume*) (soff+(sizeof(TVolume)*i)))->~G__TTVolume();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVolume*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVolume*) (soff))->~G__TTVolume();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVolumeView */
static int G__G__Table_224_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView[n];
     } else {
       p = new((void*) gvp) TVolumeView[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView;
     } else {
       p = new((void*) gvp) TVolumeView;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView((TVolumeView*) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TVolumeView((TVolumeView*) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView((TVolumeView*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TVolumeView((TVolumeView*) 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__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
(TVolumeView*) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TVolumeView(
(TVolumeView*) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView((TVolumeView*) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TVolumeView((TVolumeView*) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolumeView((TVolumeView*) G__int(libp->para[0]), (TVolumeView*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVolumeView((TVolumeView*) G__int(libp->para[0]), (TVolumeView*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolumeView(
(TVolumeView*) G__int(libp->para[0]), (TVolumeView*) G__int(libp->para[1])
, (TVolumeView*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TVolumeView(
(TVolumeView*) G__int(libp->para[0]), (TVolumeView*) G__int(libp->para[1])
, (TVolumeView*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TVolumePosition*) G__int(libp->para[2]), (TDataSet::EDataSetPass) G__int(libp->para[3])
, (TVolumeView*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TVolumeView(
*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TVolumePosition*) G__int(libp->para[2]), (TDataSet::EDataSetPass) G__int(libp->para[3])
, (TVolumeView*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TVolumePosition*) G__int(libp->para[2]), (TDataSet::EDataSetPass) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TVolumeView(
*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TVolumePosition*) G__int(libp->para[2]), (TDataSet::EDataSetPass) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TVolumePosition*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TVolumeView(
*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TVolumePosition*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TVolumeView(*(TVolume*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(*(TVolume*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TVolumeView(*(TVolume*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TVolume*) G__int(libp->para[3])
, (const Char_t*) G__int(libp->para[4]), (const Char_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TVolumeView(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TVolume*) G__int(libp->para[3])
, (const Char_t*) G__int(libp->para[4]), (const Char_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TVolume*) G__int(libp->para[3])
, (const Char_t*) G__int(libp->para[4]), (const Char_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TVolumeView(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TVolume*) G__int(libp->para[3])
, (const Char_t*) G__int(libp->para[4]), (const Char_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeView(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TVolume*) G__int(libp->para[3])
, (const Char_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TVolumeView(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TVolume*) G__int(libp->para[3])
, (const Char_t*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeView* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVolumeView((TVolume*) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVolumeView((TVolume*) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolumeView*) G__getstructoffset())->AddNode((TVolume*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumeView*) G__getstructoffset())->Add((TVolumeView*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVolumeView*) G__getstructoffset())->Add((TShape*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVolumeView*) G__getstructoffset())->Add((TShape*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolumeView*) G__getstructoffset())->GetPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolumeView*) G__getstructoffset())->GetNode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVolumeView*) G__getstructoffset())->GetGlobalRange((TVolumeView*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolumeView*) G__getstructoffset())->GetListOfShapes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumeView*) G__getstructoffset())->GetLocalRange((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVolumeView*) G__getstructoffset())->GetShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVolumeView*) G__getstructoffset())->GetVisibility());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVolumeView*) G__getstructoffset())->Is3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((TVolumeView*) G__int(libp->para[0]), (TVolumeView*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((TVolumeView*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((const Char_t*) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((const Char_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 70, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2]), (const Char_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 70, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2]), (const Char_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 70, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (const Char_t*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 70, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (TVolumeView*) G__int(libp->para[2]), (TVolumeView*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 70, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (TVolumeView*) G__int(libp->para[2]), (TVolumeView*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 70, (long) ((TVolumeView*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (TVolumeView*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolumeView*) G__getstructoffset())->Nodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TVolumeView*) G__getstructoffset())->PathP();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumeView*) G__getstructoffset())->SetLineAttributes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVolumeView*) G__getstructoffset())->SetVisibility((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumeView*) G__getstructoffset())->SetVisibility();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVolumeView::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumeView::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVolumeView::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVolumeView::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumeView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumeView::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolumeView::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumeView::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_224_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolumeView::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVolumeView G__TTVolumeView;
static int G__G__Table_224_0_51(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[] (TVolumeView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVolumeView*) (soff+(sizeof(TVolumeView)*i)))->~G__TTVolumeView();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVolumeView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVolumeView*) (soff))->~G__TTVolumeView();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVolumeViewIter */
static int G__G__Table_225_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeViewIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeViewIter(
(TVolumeView*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TVolumeViewIter(
(TVolumeView*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeViewIter((TVolumeView*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TVolumeViewIter((TVolumeView*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVolumeViewIter((TVolumeView*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TVolumeViewIter((TVolumeView*) 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__TableLN_TVolumeViewIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolumeViewIter*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVolumeViewIter*) G__getstructoffset())->UpdateTempMatrix((TVolumePosition*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVolumeViewIter*) G__getstructoffset())->ResetPosition((Int_t) G__int(libp->para[0]), (TVolumePosition*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVolumeViewIter*) G__getstructoffset())->ResetPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVolumeViewIter*) G__getstructoffset())->ResetPosition();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVolumeViewIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumeViewIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVolumeViewIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVolumeViewIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVolumeViewIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumeViewIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolumeViewIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVolumeViewIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Table_225_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVolumeViewIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Table_225_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TVolumeViewIter* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TVolumeViewIter(*(TVolumeViewIter*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVolumeViewIter G__TTVolumeViewIter;
static int G__G__Table_225_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[] (TVolumeViewIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVolumeViewIter*) (soff+(sizeof(TVolumeViewIter)*i)))->~G__TTVolumeViewIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVolumeViewIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVolumeViewIter*) (soff))->~G__TTVolumeViewIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Table_225_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVolumeViewIter* dest = (TVolumeViewIter*) G__getstructoffset();
   *dest = *(TVolumeViewIter*) libp->para[0].ref;
   const TVolumeViewIter& 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__Table__0_437(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, *(TVolumePosition*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* tableDescriptor_st */

/* TCL */

/* TTable */

/* TDataSetIter */

/* TDataSet */

/* TTableDescriptor */

/* TTableMap */

/* TTable::iterator */

/* TChair */

/* TColumnView */

/* TFileIter */

/* TFileSet */

/* TGenericTable */

/* TGenericTable::iterator */

/* TIndexTable */

/* TIndexTable::iterator */

/* TObjectSet */

/* TPoints3D */

/* TPointsArray3D */

/* TPolyLineShape */

/* TResponseTable */

/* TTableSorter */

/* TTablePoints */

/* TTable3Points */

/* TTableIter */

/* TTablePadView3D */

/* TVolumePosition */

/* TVolume */

/* TVolumeView */

/* TVolumeViewIter */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Table {
 public:
  G__Sizep2memfuncG__Table(): p(&G__Sizep2memfuncG__Table::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Table::*p)();
};

size_t G__get_sizep2memfuncG__Table()
{
  G__Sizep2memfuncG__Table 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__Table() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTable))) {
     TTable *G__Lderived;
     G__Lderived=(TTable*)0x1000;
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTable),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTable),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTable),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TDataSetIter))) {
     TDataSetIter *G__Lderived;
     G__Lderived=(TDataSetIter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSetIter),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TDataSet))) {
     TDataSet *G__Lderived;
     G__Lderived=(TDataSet*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSet),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSet),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor))) {
     TTableDescriptor *G__Lderived;
     G__Lderived=(TTableDescriptor*)0x1000;
     {
       TTable *G__Lpbase=(TTable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),G__get_linked_tagnum(&G__G__TableLN_TTable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTableMap))) {
     TTableMap *G__Lderived;
     G__Lderived=(TTableMap*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableMap),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TChair))) {
     TChair *G__Lderived;
     G__Lderived=(TChair*)0x1000;
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TChair),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TChair),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TChair),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TColumnView))) {
     TColumnView *G__Lderived;
     G__Lderived=(TColumnView*)0x1000;
     {
       TChair *G__Lpbase=(TChair*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TColumnView),G__get_linked_tagnum(&G__G__TableLN_TChair),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TColumnView),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TColumnView),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TColumnView),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TFileIter))) {
     TFileIter *G__Lderived;
     G__Lderived=(TFileIter*)0x1000;
     {
       TListIter *G__Lpbase=(TListIter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TFileIter),G__get_linked_tagnum(&G__G__TableLN_TListIter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TFileIter),G__get_linked_tagnum(&G__G__TableLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TFileIter),G__get_linked_tagnum(&G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TFileSet))) {
     TFileSet *G__Lderived;
     G__Lderived=(TFileSet*)0x1000;
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TFileSet),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TFileSet),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TFileSet),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TGenericTable))) {
     TGenericTable *G__Lderived;
     G__Lderived=(TGenericTable*)0x1000;
     {
       TTable *G__Lpbase=(TTable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTable),G__get_linked_tagnum(&G__G__TableLN_TTable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTable),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTable),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTable),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TIndexTable))) {
     TIndexTable *G__Lderived;
     G__Lderived=(TIndexTable*)0x1000;
     {
       TTable *G__Lpbase=(TTable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTable),G__get_linked_tagnum(&G__G__TableLN_TTable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTable),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTable),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTable),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TObjectSet))) {
     TObjectSet *G__Lderived;
     G__Lderived=(TObjectSet*)0x1000;
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TObjectSet),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TObjectSet),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TObjectSet),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TPoints3D))) {
     TPoints3D *G__Lderived;
     G__Lderived=(TPoints3D*)0x1000;
     {
       TPoints3DABC *G__Lpbase=(TPoints3DABC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPoints3D),G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPoints3D),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D))) {
     TPointsArray3D *G__Lderived;
     G__Lderived=(TPointsArray3D*)0x1000;
     {
       TPoints3DABC *G__Lpbase=(TPoints3DABC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D),G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape))) {
     TPolyLineShape *G__Lderived;
     G__Lderived=(TPolyLineShape*)0x1000;
     {
       TShape *G__Lpbase=(TShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape),G__get_linked_tagnum(&G__G__TableLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TResponseTable))) {
     TResponseTable *G__Lderived;
     G__Lderived=(TResponseTable*)0x1000;
     {
       TGenericTable *G__Lpbase=(TGenericTable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable),G__get_linked_tagnum(&G__G__TableLN_TGenericTable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TTable *G__Lpbase=(TTable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable),G__get_linked_tagnum(&G__G__TableLN_TTable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTableSorter))) {
     TTableSorter *G__Lderived;
     G__Lderived=(TTableSorter*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableSorter),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableSorter),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTablePoints))) {
     TTablePoints *G__Lderived;
     G__Lderived=(TTablePoints*)0x1000;
     {
       TPoints3DABC *G__Lpbase=(TPoints3DABC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTablePoints),G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTablePoints),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTable3Points))) {
     TTable3Points *G__Lderived;
     G__Lderived=(TTable3Points*)0x1000;
     {
       TTablePoints *G__Lpbase=(TTablePoints*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTable3Points),G__get_linked_tagnum(&G__G__TableLN_TTablePoints),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPoints3DABC *G__Lpbase=(TPoints3DABC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTable3Points),G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTable3Points),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TTableIter))) {
     TTableIter *G__Lderived;
     G__Lderived=(TTableIter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TTableIter),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TVolumePosition))) {
     TVolumePosition *G__Lderived;
     G__Lderived=(TVolumePosition*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumePosition),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TVolume))) {
     TVolume *G__Lderived;
     G__Lderived=(TVolume*)0x1000;
     {
       TObjectSet *G__Lpbase=(TObjectSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TObjectSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume),G__get_linked_tagnum(&G__G__TableLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TVolumeView))) {
     TVolumeView *G__Lderived;
     G__Lderived=(TVolumeView*)0x1000;
     {
       TObjectSet *G__Lpbase=(TObjectSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView),G__get_linked_tagnum(&G__G__TableLN_TObjectSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDataSet *G__Lpbase=(TDataSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView),G__get_linked_tagnum(&G__G__TableLN_TDataSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView),G__get_linked_tagnum(&G__G__TableLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView),G__get_linked_tagnum(&G__G__TableLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter))) {
     TVolumeViewIter *G__Lderived;
     G__Lderived=(TVolumeViewIter*)0x1000;
     {
       TDataSetIter *G__Lpbase=(TDataSetIter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter),G__get_linked_tagnum(&G__G__TableLN_TDataSetIter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter),G__get_linked_tagnum(&G__G__TableLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Table() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   G__search_typename2("UShort_t",114,-1,0,-1);
   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("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("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Marker_t",115,-1,0,-1);
   G__setnewtype(-1,"Marker number (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("Size_t",102,-1,0,-1);
   G__setnewtype(-1,"Attribute size (float)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TableLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TableLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TableLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TableLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TableLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TableLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TableLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TableLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TableLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TableLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EDataSetPass",117,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),0,G__get_linked_tagnum(&G__G__TableLN_TDataSet));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TDataSet::EDataSetPass (*)(TDataSet*)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TDataSet::EDataSetPass (*)(TDataSet*,void*)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Long_t>",117,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TableLN_reverse_iteratorlEvectorlElongcOallocatorlElonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TableLN_reverse_iteratorlEvectorlElongcOallocatorlElonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<long>",117,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vec_iterator",117,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vec_const_iterator",117,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator",85,G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st),0,G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMPAREMETHOD",89,-1,0,-1);
   G__setnewtype(-1,"Int_t (*COMPAREMETHOD)(const void **, const void **);",0);
   G__search_typename2("SEARCHMETHOD",89,-1,0,-1);
   G__setnewtype(-1,"Int_t (*SEARCHMETHOD) (const void *, const void **);",0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* tableDescriptor_st */
static void G__setup_memvartableDescriptor_st(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st));
   { tableDescriptor_st *p; p=(tableDescriptor_st*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fColumnName)-(long)(p)),99,0,0,-1,-1,-1,1,"fColumnName[32]=",0,"The name of this data-member: see dstype.h for dsl compatible mode ");
   G__memvar_setup((void*)((long)(&p->fIndexArray)-(long)(p)),104,0,0,-1,-1,-1,1,"fIndexArray[3]=",0,"The array of the sizes for each dimensions fIndexArray[fDimensions]");
   G__memvar_setup((void*)((long)(&p->fOffset)-(long)(p)),104,0,0,-1,-1,-1,1,"fOffset=",0,"The first byte in the row of this column                              ");
   G__memvar_setup((void*)((long)(&p->fSize)-(long)(p)),104,0,0,-1,-1,-1,1,"fSize=",0,"The full size of the selected column in bytes                         ");
   G__memvar_setup((void*)((long)(&p->fTypeSize)-(long)(p)),104,0,0,-1,-1,-1,1,"fTypeSize=",0,"The type size of the selected column in bytes                         ");
   G__memvar_setup((void*)((long)(&p->fDimensions)-(long)(p)),104,0,0,-1,-1,-1,1,"fDimensions=",0,"The number of the dimensions for array                                ");
   G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),105,0,0,-1,-1,-1,1,"fType=",0,"The data type of the selected column                                  ");
   }
   G__tag_memvar_reset();
}


   /* TCL */
static void G__setup_memvarTCL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TCL));
   { TCL *p; p=(TCL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTable */
static void G__setup_memvarTTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTable));
   { TTable *p; p=(TTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fSize=",0,"Size of the one element (row) of the table");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"Number of array elements");
   G__memvar_setup((void*)0,67,0,0,-1,G__defined_typename("Char_t"),-1,2,"fTable=",0,"Array of (fN*fSize) longs");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fMaxIndex=",0,"The used capacity of this array");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kNAN=%lldLL",(long long)TTable::kNAN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kFloat=%lldLL",(long long)TTable::kFloat).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kInt=%lldLL",(long long)TTable::kInt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kLong=%lldLL",(long long)TTable::kLong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kShort=%lldLL",(long long)TTable::kShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kDouble=%lldLL",(long long)TTable::kDouble).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kUInt=%lldLL",(long long)TTable::kUInt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kULong=%lldLL",(long long)TTable::kULong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kUShort=%lldLL",(long long)TTable::kUShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kUChar=%lldLL",(long long)TTable::kUChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kChar=%lldLL",(long long)TTable::kChar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kPtr=%lldLL",(long long)TTable::kPtr).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kBool=%lldLL",(long long)TTable::kBool).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-2,1,G__FastAllocString(2048).Format("kEndColumnType=%lldLL",(long long)TTable::kEndColumnType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLETableBits),-1,-2,1,G__FastAllocString(2048).Format("kIsNotOwn=%lldLL",(long long)TTable::kIsNotOwn).data(),0,(char*)NULL);
   G__memvar_setup((void*)(&TTable::fgTypeName),67,0,1,-1,-1,-2,1,"fgTypeName[13]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDataSetIter */
static void G__setup_memvarTDataSetIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSetIter));
   { TDataSetIter *p; p=(TDataSetIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TIter),-1,-1,2,"fNext=",0,"\"standard\" ROOT iterator for containers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TIter),-1,-1,2,"fNextSet[100]=",0,"the list of the TList iterators to bypass the whole dataset");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDepth=",0,"the current depth of the passing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxDepth=",0,"the max depth of the passing (=1 by default)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDataSet),-1,-1,2,"fDataSet=",0,"Pointer to the last selected TDataSet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDataSet),-1,-1,2,"fRootDataSet=",0,"Pointer to the root TDataSet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDataSet),-1,-1,2,"fWorkingDataSet=",0,"Pointer to the working TDataSet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDataSet),-1,-2,2,"fgNullDataSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDataSet */
static void G__setup_memvarTDataSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSet));
   { TDataSet *p; p=(TDataSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kContinue=%lldLL",(long long)TDataSet::kContinue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kPrune=%lldLL",(long long)TDataSet::kPrune).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kStop=%lldLL",(long long)TDataSet::kStop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kUp=%lldLL",(long long)TDataSet::kUp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kStruct=%lldLL",(long long)TDataSet::kStruct).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TDataSet::kAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kRefs=%lldLL",(long long)TDataSet::kRefs).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass),-1,-2,1,G__FastAllocString(2048).Format("kMarked=%lldLL",(long long)TDataSet::kMarked).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDataSet),-1,-2,2,"fgMainSet=",0,"pointer the main dataset;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDataSet),-1,-1,2,"fParent=",0,"pointer to mother of the directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TSeqCollection),-1,-1,2,"fList=",0,"List of the the the objects included into this dataset");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLESetBits),-1,-2,1,G__FastAllocString(2048).Format("kMark=%lldLL",(long long)TDataSet::kMark).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLESetBits),-1,-2,1,G__FastAllocString(2048).Format("kArray=%lldLL",(long long)TDataSet::kArray).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEBitOpt),-1,-2,1,G__FastAllocString(2048).Format("kSet=%lldLL",(long long)TDataSet::kSet).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEBitOpt),-1,-2,1,G__FastAllocString(2048).Format("kReset=%lldLL",(long long)TDataSet::kReset).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTableDescriptor */
static void G__setup_memvarTTableDescriptor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor));
   { TTableDescriptor *p; p=(TTableDescriptor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-1,2,"fRowClass=",0,"TClass defining ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),-1,-1,2,"fSecondDescriptor=",0,"shadow descriptor ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_TString),-1,-2,2,"fgCommentsName=",0,"The name of dataset to keep the comments fields");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),-1,-2,2,"fgColDescriptors=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTableMap */
static void G__setup_memvarTTableMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTableMap));
   { TTableMap *p; p=(TTableMap*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable),-1,-1,2,"fTable=",0,"pointer to the refered TTable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTable::iterator */
static void G__setup_memvarTTablecLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator));
   { TTable::iterator *p; p=(TTable::iterator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fRowSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable),-1,-1,4,"fThisTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgRcLcLiterator),G__defined_typename("vec_iterator"),-1,4,"fCurrentRow=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TChair */
static void G__setup_memvarTChair(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TChair));
   { TChair *p; p=(TChair*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TTable),-1,-1,2,"fTable=",0,"the \"TTable\" object this object is pthe proxy for");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fLastIndx=",0,"index pof the last used  table row;");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fLastRow=",0,"pointer to the last used table row; fLastRow = table[fLastIndx]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TColumnView */
static void G__setup_memvarTColumnView(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TColumnView));
   { TColumnView *p; p=(TColumnView*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFileIter */
static void G__setup_memvarTFileIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TFileIter));
   { TFileIter *p; p=(TFileIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TFile),-1,-1,4,"fFileBackUp=",0,"! temporary data-members");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDirectory),-1,-1,4,"fDirectoryBackUp=",0,"! to save/restore TFile/TDirectory global scope");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TFileIter),-1,-1,4,"fNestedIterator=",0,"! The inner TFidrectory interator;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TDirectory),-1,-1,2,"fRootFile=",0,"TDirectory/TFile to be iterated over");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_TString),-1,-1,2,"fEventName=",0,"current key name");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fRunNumber=",0,"current \"run number\"");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEventNumber=",0,"current \"event number\"");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCursorPosition=",0,"the position of the current key in the sorted TKey list");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnTFile=",0,"Bit whether this classs creates TFile on its own to delete");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFileSet */
static void G__setup_memvarTFileSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TFileSet));
   { TFileSet *p; p=(TFileSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGenericTable */
static void G__setup_memvarTGenericTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTable));
   { TGenericTable *p; p=(TGenericTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),-1,-1,2,"fColDescriptors=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGenericTable::iterator */
static void G__setup_memvarTGenericTablecLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator));
   { TGenericTable::iterator *p; p=(TGenericTable::iterator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fRowSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fCurrentRow=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TIndexTable */
static void G__setup_memvarTIndexTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTable));
   { TIndexTable *p; p=(TIndexTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable),-1,-1,2,"fRefTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor),-1,-2,2,"fgColDescriptors=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TIndexTable::iterator */
static void G__setup_memvarTIndexTablecLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator));
   { TIndexTable::iterator *p; p=(TIndexTable::iterator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable),-1,-1,2,"fTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,73,0,1,-1,-1,-1,2,"fCurrentRow=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObjectSet */
static void G__setup_memvarTObjectSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TObjectSet));
   { TObjectSet *p; p=(TObjectSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TObjectSetcLcLEOwnerBits),-1,-2,2,"kIsOwner=8388608LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TObject),-1,-1,2,"fObj=",0,"TObject to be inserted");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPoints3D */
static void G__setup_memvarTPoints3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TPoints3D));
   { TPoints3D *p; p=(TPoints3D*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TPoints3DcLcLEOwnerBits),-1,-2,2,"kIsOwner=8388608LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC),-1,-1,2,"fPoints=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPointsArray3D */
static void G__setup_memvarTPointsArray3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D));
   { TPointsArray3D *p; p=(TPointsArray3D*)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,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fP=",0,"Array of 3-D coordinates  (x,y,z)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_TString),-1,-1,2,"fOption=",0,"options");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fGLList=",0,"The list number for OpenGL view");
   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,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPolyLineShape */
static void G__setup_memvarTPolyLineShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape));
   { TPolyLineShape *p; p=(TPolyLineShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPointFlag=",0,"Flag whether we should paint \"points\" (option \"P\")");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLineFlag=",0,"Flag whether we should connect the points with \"line\" (option \"L\")");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TableLN_EShapeTypes),-1,-1,2,"fShapeType=",0,"shape of the segment connections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TShape),-1,-1,2,"fShape=",0,"shape for draw each segment of the polylins");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TShape),-1,-1,2,"fConnection=",0,"shape to represent the each \"end\" of the polyline");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC),-1,-1,2,"fPoints=",0,"PolyLine itself");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWidthFactor=",0,"factor to calculate the the tube diameters");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasDrawn=",0,"flag to avoid multiply plots");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmooth=",0,"Make smooth connections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN__x3d_sizeof_),G__defined_typename("Size3D"),-1,2,"fSizeX3D=",0,"! the X3D buffer sizes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TResponseTable */
static void G__setup_memvarTResponseTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable));
   { TResponseTable *p; p=(TResponseTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fResponseLocation=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTableSorter */
static void G__setup_memvarTTableSorter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTableSorter));
   { TTableSorter *p; p=(TTableSorter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_TTableSortercLcL212),-1,-1,4,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,2,0,-1,-1,-1,2,"fSortIndex=",0,"Array of pointers to columns of the sorted table");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastFound=",0,"The index of the last found index within fSortIndex");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFirstRow=",0,"first row of the table to be sorted");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumberOfRows=",0,"number of rows of the table to be sorted");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_TString),-1,-1,2,"fColName=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColOffset=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColSize=",0,"The size of the selected column in bytes");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndexArray=",0,"\"parsed\" indecis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColDimensions=",0,"The number of the dimensions for array (=-1 means it is a \"simple\" array)");
   G__memvar_setup((void*)0,67,0,1,-1,G__defined_typename("Char_t"),-1,2,"fsimpleArray=",0,"Pointer to the \"simple\" array;");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable),-1,-1,2,"fParentTable=",0,"!- the back pointer to the sorted table");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("SEARCHMETHOD"),-1,2,"fSearchMethod=",0,"Function selected to search values");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("COMPAREMETHOD"),-1,2,"fCompareMethod=",0,"Function to sort the original array");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType),-1,-1,2,"fColType=",0,"data type of the selected column");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fParentRowSize=",0,"To be filled from TTable::GetRowSize() method");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-1,2,"fFirstParentRow=",0,"! pointer to the internal array of TTable object;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTablePoints */
static void G__setup_memvarTTablePoints(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTablePoints));
   { TTablePoints *p; p=(TTablePoints*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TTableSorter),-1,-1,2,"fTableSorter=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,1,-1,-1,-1,2,"fKey=",0,"pointer to key value to select rows");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFirstRow=",0,"The first row to take in account");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fRows=",0,"Pointer the first row of the STAF table");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTable3Points */
static void G__setup_memvarTTable3Points(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTable3Points));
   { TTable3Points *p; p=(TTable3Points*)0x1000; if (p) { }
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fColumnOffset=",0,"!");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable3PointscLcLEPointDirection),-1,-2,1,G__FastAllocString(2048).Format("kXPoints=%lldLL",(long long)TTable3Points::kXPoints).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable3PointscLcLEPointDirection),-1,-2,1,G__FastAllocString(2048).Format("kYPoints=%lldLL",(long long)TTable3Points::kYPoints).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable3PointscLcLEPointDirection),-1,-2,1,G__FastAllocString(2048).Format("kZPoints=%lldLL",(long long)TTable3Points::kZPoints).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TTable3PointscLcLEPointDirection),-1,-2,1,G__FastAllocString(2048).Format("kTotalSize=%lldLL",(long long)TTable3Points::kTotalSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTableIter */
static void G__setup_memvarTTableIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   { TTableIter *p; p=(TTableIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TableLN_TTableSorter),-1,-1,4,"fTableSorter=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIndx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTotalKeys=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFirstIndx=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTablePadView3D */
static void G__setup_memvarTTablePadView3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D));
   { TTablePadView3D *p; p=(TTablePadView3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TVirtualPad),-1,-1,2,"fParent=",0,"Pointer to the original TPad object");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fViewBoxMin[3]=",0,"Minimum of clip box");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fViewBoxMax[3]=",0,"Maximum of clip box");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTranslate[3]=",0,"The vector to move object into the center of the scene");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fExtraTranslate[3]=",0,"The vector to move object with a mouse");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngles[3]=",0,"Latitude, Longitude, Psi");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fExtraAngles[3]=",0,"Latitude, Longitude, Psi");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAnglFactor[3]=",0,"Latitude, Longitude, Psi");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScale=",0,"The scale factor to control the border of the clip box");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVolumePosition */
static void G__setup_memvarTVolumePosition(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumePosition));
   { TVolumePosition *p; p=(TVolumePosition*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX[3]=",0,"X offset with respect to parent object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TRotMatrix),-1,-1,2,"fMatrix=",0,"Pointer to rotation matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TVolume),-1,-1,2,"fNode=",0,"Refs pointer to the node defined");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fId=",0,"Unique ID of this position");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TVolumePositioncLcLEPositionBits),-1,-2,1,G__FastAllocString(2048).Format("kIsOwn=%lldLL",(long long)TVolumePosition::kIsOwn).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVolume */
static void G__setup_memvarTVolume(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume));
   { TVolume *p; p=(TVolume*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TVolumecLcLENodeSEEN),-1,-2,1,G__FastAllocString(2048).Format("kBothVisible=%lldLL",(long long)TVolume::kBothVisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TVolumecLcLENodeSEEN),-1,-2,1,G__FastAllocString(2048).Format("kSonUnvisible=%lldLL",(long long)TVolume::kSonUnvisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TVolumecLcLENodeSEEN),-1,-2,1,G__FastAllocString(2048).Format("kThisUnvisible=%lldLL",(long long)TVolume::kThisUnvisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TableLN_TVolumecLcLENodeSEEN),-1,-2,1,G__FastAllocString(2048).Format("kNoneVisible=%lldLL",(long long)TVolume::kNoneVisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TShape),-1,-1,2,"fShape=",0,"Pointer to the \"master\" shape definition");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TList),-1,-1,2,"fListOfShapes=",0,"Pointer to the list of the shape definitions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TableLN_TString),-1,-1,2,"fOption=",0,"List of options if any");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TableLN_TVolumecLcLENodeSEEN),-1,-1,2,"fVisibility=",0,"Visibility flag  00 - everything visible,");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVolumeView */
static void G__setup_memvarTVolumeView(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   { TVolumeView *p; p=(TVolumeView*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TList),-1,-1,2,"fListOfShapes=",0,"Pointer to the list of the \"extra\" shape definitions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVolumeViewIter */
static void G__setup_memvarTVolumeViewIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter));
   { TVolumeViewIter *p; p=(TVolumeViewIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TObjArray),-1,-1,2,"fPositions=",0,"the array of the Node position in the absolute system");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TableLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Table() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfunctableDescriptor_st(void) {
   /* tableDescriptor_st */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st));
   // automatic default constructor
   G__memfunc_setup("tableDescriptor_st", 1901, G__G__Table_99_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("tableDescriptor_st", 1901, G__G__Table_99_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 0, 1, 1, 1, 0, "u 'tableDescriptor_st' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~tableDescriptor_st", 2027, G__G__Table_99_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Table_99_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 1, 1, 1, 1, 0, "u 'tableDescriptor_st' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCL(void) {
   /* TCL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TCL));
   G__memfunc_setup("ucopy",560,G__G__Table_101_0_1, 73, -1, -1, 0, 3, 3, 1, 0, 
"I - - 10 - b I - - 0 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (int* (*)(const int*, int*, int))(&TCL::ucopy) ), 0);
   G__memfunc_setup("ucopy",560,G__G__Table_101_0_2, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - b F - - 0 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::ucopy) ), 0);
   G__memfunc_setup("ucopy",560,G__G__Table_101_0_3, 68, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - b D - - 0 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const float*, double*, int))(&TCL::ucopy) ), 0);
   G__memfunc_setup("ucopy",560,G__G__Table_101_0_4, 70, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - b F - - 0 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const double*, float*, int))(&TCL::ucopy) ), 0);
   G__memfunc_setup("ucopy",560,G__G__Table_101_0_5, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - b D - - 0 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::ucopy) ), 0);
   G__memfunc_setup("ucopy",560,G__G__Table_101_0_6, 89, -1, -1, 2, 3, 3, 1, 0, 
"Y - - 12 - b Y - - 2 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (void** (*)(const void**, void**, int))(&TCL::ucopy) ), 0);
   G__memfunc_setup("vzero",566,G__G__Table_101_0_7, 70, -1, -1, 0, 2, 3, 1, 0, 
"F - - 0 - a i - - 0 - n1", (char*)NULL, (void*) G__func2void( (float* (*)(float*, int))(&TCL::vzero) ), 0);
   G__memfunc_setup("vzero",566,G__G__Table_101_0_8, 68, -1, -1, 0, 2, 3, 1, 0, 
"D - - 0 - a i - - 0 - n1", (char*)NULL, (void*) G__func2void( (double* (*)(double*, int))(&TCL::vzero) ), 0);
   G__memfunc_setup("vzero",566,G__G__Table_101_0_9, 89, -1, -1, 2, 2, 3, 1, 0, 
"Y - - 2 - a i - - 0 - n1", (char*)NULL, (void*) G__func2void( (void** (*)(void**, int))(&TCL::vzero) ), 0);
   G__memfunc_setup("vadd",415,G__G__Table_101_0_10, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - b F - - 10 - c "
"F - - 0 - a i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int))(&TCL::vadd) ), 0);
   G__memfunc_setup("vadd",415,G__G__Table_101_0_11, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - b D - - 10 - c "
"D - - 0 - a i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int))(&TCL::vadd) ), 0);
   G__memfunc_setup("vadd",415,G__G__Table_101_0_12, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - b D - - 10 - c "
"F - - 0 - a i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const double*, float*, int))(&TCL::vadd) ), 0);
   G__memfunc_setup("vadd",415,G__G__Table_101_0_13, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - b F - - 10 - c "
"D - - 0 - a i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const float*, double*, int))(&TCL::vadd) ), 0);
   G__memfunc_setup("vdot",445,G__G__Table_101_0_14, 102, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - b F - - 10 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float (*)(const float*, const float*, int))(&TCL::vdot) ), 0);
   G__memfunc_setup("vdot",445,G__G__Table_101_0_15, 100, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - b D - - 10 - a "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double (*)(const double*, const double*, int))(&TCL::vdot) ), 0);
   G__memfunc_setup("vsub",448,G__G__Table_101_0_16, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - a F - - 10 - b "
"F - - 0 - x i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int))(&TCL::vsub) ), 0);
   G__memfunc_setup("vsub",448,G__G__Table_101_0_17, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - x i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int))(&TCL::vsub) ), 0);
   G__memfunc_setup("vsub",448,G__G__Table_101_0_18, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - b D - - 10 - c "
"F - - 0 - a i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const double*, float*, int))(&TCL::vsub) ), 0);
   G__memfunc_setup("vsub",448,G__G__Table_101_0_19, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - b F - - 10 - c "
"D - - 0 - a i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const float*, double*, int))(&TCL::vsub) ), 0);
   G__memfunc_setup("vcopyn",671,G__G__Table_101_0_20, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - a F - - 0 - x "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::vcopyn) ), 0);
   G__memfunc_setup("vcopyn",671,G__G__Table_101_0_21, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - a D - - 0 - x "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::vcopyn) ), 0);
   G__memfunc_setup("vscale",638,G__G__Table_101_0_22, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - a f - - 0 - scale "
"F - - 0 - b i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float, float*, int))(&TCL::vscale) ), 0);
   G__memfunc_setup("vscale",638,G__G__Table_101_0_23, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - a d - - 0 - scale "
"D - - 0 - b i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double, double*, int))(&TCL::vscale) ), 0);
   G__memfunc_setup("vlinco",651,G__G__Table_101_0_24, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a f - - 0 - fa "
"F - - 10 - b f - - 0 - fb "
"F - - 0 - x i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float, const float*, float, float*, int))(&TCL::vlinco) ), 0);
   G__memfunc_setup("vlinco",651,G__G__Table_101_0_25, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a d - - 0 - fa "
"D - - 10 - b d - - 0 - fb "
"D - - 0 - x i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double, const double*, double, double*, int))(&TCL::vlinco) ), 0);
   G__memfunc_setup("vmatl",548,G__G__Table_101_0_26, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - G F - - 10 - c "
"F - - 0 - x i - - 0 '3' n "
"i - - 0 '3' m", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::vmatl) ), 0);
   G__memfunc_setup("vmatl",548,G__G__Table_101_0_27, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - G D - - 10 - c "
"D - - 0 - x i - - 0 '3' n "
"i - - 0 '3' m", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::vmatl) ), 0);
   G__memfunc_setup("vmatr",554,G__G__Table_101_0_28, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - c F - - 10 - G "
"F - - 0 - x i - - 0 '3' n "
"i - - 0 '3' m", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::vmatr) ), 0);
   G__memfunc_setup("vmatr",554,G__G__Table_101_0_29, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - c D - - 10 - G "
"D - - 0 - x i - - 0 '3' n "
"i - - 0 '3' m", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::vmatr) ), 0);
   G__memfunc_setup("mxmad_0_",773,G__G__Table_101_0_30, 70, -1, -1, 0, 7, 3, 1, 0, 
"i - - 0 - n F - - 10 - a "
"F - - 10 - b F - - 0 - c "
"i - - 0 - i i - - 0 - j "
"i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(int, const float*, const float*, float*, int, int, int))(&TCL::mxmad_0_) ), 0);
   G__memfunc_setup("mxmad",535,G__G__Table_101_0_31, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a F - - 10 - b "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmad) ), 0);
   G__memfunc_setup("mxmad1",584,G__G__Table_101_0_32, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a F - - 10 - q "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmad1) ), 0);
   G__memfunc_setup("mxmad2",585,G__G__Table_101_0_33, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - p F - - 10 - b "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmad2) ), 0);
   G__memfunc_setup("mxmad3",586,G__G__Table_101_0_34, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - p F - - 10 - q "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmad3) ), 0);
   G__memfunc_setup("mxmpy",571,G__G__Table_101_0_35, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a F - - 10 - b "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmpy) ), 0);
   G__memfunc_setup("mxmpy1",620,G__G__Table_101_0_36, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a F - - 10 - q "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmpy1) ), 0);
   G__memfunc_setup("mxmpy2",621,G__G__Table_101_0_37, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - p F - - 10 - b "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmpy2) ), 0);
   G__memfunc_setup("mxmpy3",622,G__G__Table_101_0_38, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - p F - - 10 - q "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmpy3) ), 0);
   G__memfunc_setup("mxmub",553,G__G__Table_101_0_39, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a F - - 10 - b "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmub) ), 0);
   G__memfunc_setup("mxmub1",602,G__G__Table_101_0_40, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - a F - - 10 - q "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmub1) ), 0);
   G__memfunc_setup("mxmub2",603,G__G__Table_101_0_41, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - p F - - 10 - b "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmub2) ), 0);
   G__memfunc_setup("mxmub3",604,G__G__Table_101_0_42, 70, -1, -1, 0, 6, 3, 1, 0, 
"F - - 10 - p F - - 10 - q "
"F - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int, int))(&TCL::mxmub3) ), 0);
   G__memfunc_setup("mxmlrt_0_",914,G__G__Table_101_0_43, 70, -1, -1, 0, 6, 3, 1, 0, 
"i - - 0 - n__ F - - 10 - a "
"F - - 10 - b F - - 0 - c "
"i - - 0 - ni i - - 0 - nj", (char*)NULL, (void*) G__func2void( (float* (*)(int, const float*, const float*, float*, int, int))(&TCL::mxmlrt_0_) ), 0);
   G__memfunc_setup("mxmlrt",676,G__G__Table_101_0_44, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - b "
"F - - 0 - x i - - 0 - ni "
"i - - 0 - nj", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::mxmlrt) ), 0);
   G__memfunc_setup("mxmltr",676,G__G__Table_101_0_45, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - b "
"F - - 0 - x i - - 0 - ni "
"i - - 0 - nj", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::mxmltr) ), 0);
   G__memfunc_setup("mxtrp",571,G__G__Table_101_0_46, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - a F - - 0 - b "
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int, int))(&TCL::mxtrp) ), 0);
   G__memfunc_setup("mxmad_0_",773,G__G__Table_101_0_47, 68, -1, -1, 0, 7, 3, 1, 0, 
"i - - 0 - n D - - 10 - a "
"D - - 10 - b D - - 0 - c "
"i - - 0 - i i - - 0 - j "
"i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(int, const double*, const double*, double*, int, int, int))(&TCL::mxmad_0_) ), 0);
   G__memfunc_setup("mxmad",535,G__G__Table_101_0_48, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmad) ), 0);
   G__memfunc_setup("mxmad1",584,G__G__Table_101_0_49, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmad1) ), 0);
   G__memfunc_setup("mxmad2",585,G__G__Table_101_0_50, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmad2) ), 0);
   G__memfunc_setup("mxmad3",586,G__G__Table_101_0_51, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmad3) ), 0);
   G__memfunc_setup("mxmpy",571,G__G__Table_101_0_52, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmpy) ), 0);
   G__memfunc_setup("mxmpy1",620,G__G__Table_101_0_53, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmpy1) ), 0);
   G__memfunc_setup("mxmpy2",621,G__G__Table_101_0_54, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmpy2) ), 0);
   G__memfunc_setup("mxmpy3",622,G__G__Table_101_0_55, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmpy3) ), 0);
   G__memfunc_setup("mxmub",553,G__G__Table_101_0_56, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmub) ), 0);
   G__memfunc_setup("mxmub1",602,G__G__Table_101_0_57, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmub1) ), 0);
   G__memfunc_setup("mxmub2",603,G__G__Table_101_0_58, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmub2) ), 0);
   G__memfunc_setup("mxmub3",604,G__G__Table_101_0_59, 68, -1, -1, 0, 6, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - i "
"i - - 0 - j i - - 0 - k", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int, int))(&TCL::mxmub3) ), 0);
   G__memfunc_setup("mxmlrt_0_",914,G__G__Table_101_0_60, 68, -1, -1, 0, 6, 3, 1, 0, 
"i - - 0 - n__ D - - 10 - a "
"D - - 10 - b D - - 0 - c "
"i - - 0 - ni i - - 0 - nj", (char*)NULL, (void*) G__func2void( (double* (*)(int, const double*, const double*, double*, int, int))(&TCL::mxmlrt_0_) ), 0);
   G__memfunc_setup("mxmlrt",676,G__G__Table_101_0_61, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - ni "
"i - - 0 - nj", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::mxmlrt) ), 0);
   G__memfunc_setup("mxmltr",676,G__G__Table_101_0_62, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - b "
"D - - 0 - c i - - 0 - ni "
"i - - 0 - nj", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::mxmltr) ), 0);
   G__memfunc_setup("mxtrp",571,G__G__Table_101_0_63, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - a D - - 0 - b "
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int, int))(&TCL::mxtrp) ), 0);
   G__memfunc_setup("traat",540,G__G__Table_101_0_64, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - a F - - 0 - s "
"i - - 0 - m i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int, int))(&TCL::traat) ), 0);
   G__memfunc_setup("tral",435,G__G__Table_101_0_65, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - u "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::tral) ), 0);
   G__memfunc_setup("tralt",551,G__G__Table_101_0_66, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - u "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::tralt) ), 0);
   G__memfunc_setup("tras",442,G__G__Table_101_0_67, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - s "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::tras) ), 0);
   G__memfunc_setup("trasat",655,G__G__Table_101_0_68, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - s "
"F - - 0 - r i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::trasat) ), 0);
   G__memfunc_setup("trasat",655,G__G__Table_101_0_69, 70, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a F - - 10 - s "
"F - - 0 - r i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const double*, const float*, float*, int, int))(&TCL::trasat) ), 0);
   G__memfunc_setup("trata",540,G__G__Table_101_0_70, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - a F - - 0 - r "
"i - - 0 - m i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int, int))(&TCL::trata) ), 0);
   G__memfunc_setup("trats",558,G__G__Table_101_0_71, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - s "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::trats) ), 0);
   G__memfunc_setup("tratsa",655,G__G__Table_101_0_72, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - a F - - 10 - s "
"F - - 0 - r i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::tratsa) ), 0);
   G__memfunc_setup("trchlu",658,G__G__Table_101_0_73, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - a F - - 0 - b "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trchlu) ), 0);
   G__memfunc_setup("trchul",658,G__G__Table_101_0_74, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - a F - - 0 - b "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trchul) ), 0);
   G__memfunc_setup("trinv",563,G__G__Table_101_0_75, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - t F - - 0 - s "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trinv) ), 0);
   G__memfunc_setup("trla",435,G__G__Table_101_0_76, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - u F - - 10 - a "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::trla) ), 0);
   G__memfunc_setup("trlta",551,G__G__Table_101_0_77, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - u F - - 10 - a "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::trlta) ), 0);
   G__memfunc_setup("trpck",548,G__G__Table_101_0_78, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - s F - - 0 - u "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trpck) ), 0);
   G__memfunc_setup("trqsq",571,G__G__Table_101_0_79, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 10 - q F - - 10 - s "
"F - - 0 - r i - - 0 - m", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int))(&TCL::trqsq) ), 0);
   G__memfunc_setup("trsa",442,G__G__Table_101_0_80, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - s F - - 10 - a "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::trsa) ), 0);
   G__memfunc_setup("trsinv",678,G__G__Table_101_0_81, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - g F - - 0 - gi "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trsinv) ), 0);
   G__memfunc_setup("trsmlu",679,G__G__Table_101_0_82, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - u F - - 0 - s "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trsmlu) ), 0);
   G__memfunc_setup("trsmul",679,G__G__Table_101_0_83, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - g F - - 0 - gi "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trsmul) ), 0);
   G__memfunc_setup("trupck",665,G__G__Table_101_0_84, 70, -1, -1, 0, 3, 3, 1, 0, 
"F - - 10 - u F - - 0 - s "
"i - - 0 - m", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, float*, int))(&TCL::trupck) ), 0);
   G__memfunc_setup("trsat",558,G__G__Table_101_0_85, 70, -1, -1, 0, 5, 3, 1, 0, 
"F - - 10 - s F - - 10 - a "
"F - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (float* (*)(const float*, const float*, float*, int, int))(&TCL::trsat) ), 0);
   G__memfunc_setup("trsequ",676,G__G__Table_101_0_86, 70, -1, -1, 0, 4, 3, 1, 0, 
"F - - 0 - smx i - - 0 '3' m "
"F - - 0 '0' b i - - 0 '1' n", (char*)NULL, (void*) G__func2void( (float* (*)(float*, int, float*, int))(&TCL::trsequ) ), 0);
   G__memfunc_setup("traat",540,G__G__Table_101_0_87, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - a D - - 0 - s "
"i - - 0 - m i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int, int))(&TCL::traat) ), 0);
   G__memfunc_setup("tral",435,G__G__Table_101_0_88, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - u "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::tral) ), 0);
   G__memfunc_setup("tralt",551,G__G__Table_101_0_89, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - u "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::tralt) ), 0);
   G__memfunc_setup("tras",442,G__G__Table_101_0_90, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - s "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::tras) ), 0);
   G__memfunc_setup("trasat",655,G__G__Table_101_0_91, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - s "
"D - - 0 - r i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::trasat) ), 0);
   G__memfunc_setup("trata",540,G__G__Table_101_0_92, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - a D - - 0 - r "
"i - - 0 - m i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int, int))(&TCL::trata) ), 0);
   G__memfunc_setup("trats",558,G__G__Table_101_0_93, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - s "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::trats) ), 0);
   G__memfunc_setup("tratsa",655,G__G__Table_101_0_94, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - a D - - 10 - s "
"D - - 0 - r i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::tratsa) ), 0);
   G__memfunc_setup("trchlu",658,G__G__Table_101_0_95, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - a D - - 0 - b "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trchlu) ), 0);
   G__memfunc_setup("trchul",658,G__G__Table_101_0_96, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - a D - - 0 - b "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trchul) ), 0);
   G__memfunc_setup("trinv",563,G__G__Table_101_0_97, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - t D - - 0 - s "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trinv) ), 0);
   G__memfunc_setup("trla",435,G__G__Table_101_0_98, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - u D - - 10 - a "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::trla) ), 0);
   G__memfunc_setup("trlta",551,G__G__Table_101_0_99, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - u D - - 10 - a "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::trlta) ), 0);
   G__memfunc_setup("trpck",548,G__G__Table_101_0_100, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - s D - - 0 - u "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trpck) ), 0);
   G__memfunc_setup("trqsq",571,G__G__Table_101_0_101, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 10 - q D - - 10 - s "
"D - - 0 - r i - - 0 - m", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int))(&TCL::trqsq) ), 0);
   G__memfunc_setup("trsa",442,G__G__Table_101_0_102, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - s D - - 10 - a "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::trsa) ), 0);
   G__memfunc_setup("trsinv",678,G__G__Table_101_0_103, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - g D - - 0 - gi "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trsinv) ), 0);
   G__memfunc_setup("trsmlu",679,G__G__Table_101_0_104, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - u D - - 0 - s "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trsmlu) ), 0);
   G__memfunc_setup("trsmul",679,G__G__Table_101_0_105, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - g D - - 0 - gi "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trsmul) ), 0);
   G__memfunc_setup("trupck",665,G__G__Table_101_0_106, 68, -1, -1, 0, 3, 3, 1, 0, 
"D - - 10 - u D - - 0 - s "
"i - - 0 - m", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, double*, int))(&TCL::trupck) ), 0);
   G__memfunc_setup("trsat",558,G__G__Table_101_0_107, 68, -1, -1, 0, 5, 3, 1, 0, 
"D - - 10 - s D - - 10 - a "
"D - - 0 - b i - - 0 - m "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (double* (*)(const double*, const double*, double*, int, int))(&TCL::trsat) ), 0);
   G__memfunc_setup("trsequ",676,G__G__Table_101_0_108, 68, -1, -1, 0, 4, 3, 1, 0, 
"D - - 0 - smx i - - 0 '3' m "
"D - - 0 '0' b i - - 0 '1' n", (char*)NULL, (void*) G__func2void( (double* (*)(double*, int, double*, int))(&TCL::trsequ) ), 0);
   G__memfunc_setup("Class",502,G__G__Table_101_0_109, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_101_0_110, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_101_0_111, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_101_0_112, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Table_101_0_113, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Table_101_0_114, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Table_101_0_115, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Table_101_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_101_0_117, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_101_0_118, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_101_0_119, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_101_0_120, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCL::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TCL", 227, G__G__Table_101_0_121, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TCL), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TCL", 227, G__G__Table_101_0_122, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TCL), -1, 0, 1, 1, 1, 0, "u 'TCL' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCL", 353, G__G__Table_101_0_123, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Table_101_0_124, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TCL), -1, 1, 1, 1, 1, 0, "u 'TCL' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTable(void) {
   /* TTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTable));
   G__memfunc_setup("BoundsOk",805,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OutOfBoundsError",1634,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyStruct",1056,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - 'Char_t' 0 - dest C - 'Char_t' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EntryLoop",940,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 2, 0, 
"C - 'Char_t' 10 - exprFileName i - 'Int_t' 1 - action "
"U 'TObject' - 0 - obj i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetfN",480,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "l - 'Long_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTablePointer",1525,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "Y - - 0 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUsedRows",1128,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetType",718,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 50 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerHeader",1420,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'TBuffer' - 1 - b s - 'Version_t' 0 '3' version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerTable",1323,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'TBuffer' - 1 - b s - 'Version_t' 0 '3' version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDescriptorPointer",2080,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDescriptorPointer",2092,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TTableDescriptor' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReAlloc",674,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TableDictionary",1534,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 3, 3, 2, 1, 
"C - - 10 - className C - - 10 - structName "
"U 'TTableDescriptor' - 1 - ColDescriptors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable",572,G__G__Table_102_0_18, 105, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' name i - 'Int_t' 0 '0' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable",572,G__G__Table_102_0_19, 105, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n "
"i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable",572,G__G__Table_102_0_20, 105, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n "
"C - 'Char_t' 0 - array i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable",572,G__G__Table_102_0_21, 105, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - type "
"i - 'Int_t' 0 - n C - 'Char_t' 0 - array "
"i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable",572,G__G__Table_102_0_22, 105, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 1, 1, 1, 0, "u 'TTable' - 11 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Table_102_0_23, 117, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 1, 1, 1, 1, 0, "u 'TTable' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Table_102_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n Y - - 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,G__G__Table_102_0_25, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "Y - - 10 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,G__G__Table_102_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 10 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset i - 'Int_t' 0 '0' idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AppendRows",1027,G__G__Table_102_0_28, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"Y - - 10 - row h - 'UInt_t' 0 - nRows", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AsString",811,G__G__Table_102_0_29, 121, -1, -1, 0, 4, 1, 1, 8, 
"Y - - 0 - buf i 'TTable::EColumnType' - 0 - type "
"i - 'Int_t' 0 - width u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__G__Table_102_0_30, 89, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopySet",711,G__G__Table_102_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TTable' - 1 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyRows",838,G__G__Table_102_0_33, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"U 'TTable' - 10 - srcTable l - 'Long_t' 0 '0' srcRow "
"l - 'Long_t' 0 '0' dstRow l - 'Long_t' 0 '0' nRows "
"g - 'Bool_t' 0 'kFALSE' expand", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteRows",1022,G__G__Table_102_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - indx h - 'UInt_t' 0 '1' nRows", (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 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Table_102_0_36, 85, G__get_linked_tagnum(&G__G__TableLN_TH1), -1, 0, 5, 1, 1, 0, 
"u 'TCut' - 0 - varexp u 'TCut' - 0 - selection "
"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Table_102_0_37, 85, G__get_linked_tagnum(&G__G__TableLN_TH1), -1, 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetArray",799,G__G__Table_102_0_38, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowClass",1102,G__G__Table_102_0_39, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__Table_102_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNRows",793,G__G__Table_102_0_41, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowSize",1011,G__G__Table_102_0_42, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableSize",1187,G__G__Table_102_0_43, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableDescriptors",1946,G__G__Table_102_0_44, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowDescriptors",1770,G__G__Table_102_0_45, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Table_102_0_46, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Table_102_0_47, 121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - formula C - - 10 - varexp "
"C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("HasData",662,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertRows",1056,G__G__Table_102_0_49, 108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0, 
"Y - - 10 - rows l - 'Long_t' 0 - indx "
"h - 'UInt_t' 0 '1' nRows", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NaN",253,G__G__Table_102_0_51, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("New",298,G__G__Table_102_0_52, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 4, 3, 1, 0, 
"C - 'Char_t' 10 - name C - 'Char_t' 10 - type "
"Y - - 0 - array h - 'UInt_t' 0 - size", (char*)NULL, (void*) G__func2void( (TTable* (*)(const Char_t*, const Char_t*, void*, UInt_t))(&TTable::New) ), 0);
   G__memfunc_setup("MakeExpression",1454,G__G__Table_102_0_53, 67, -1, G__defined_typename("Char_t"), 0, 2, 1, 1, 0, 
"C - 'Char_t' 12 - expressions i - 'Int_t' 0 - nExpressions", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Table_102_0_54, 67, -1, G__defined_typename("Char_t"), 0, 2, 1, 1, 8, 
"C - 'Char_t' 0 - buf i - 'Int_t' 0 - n", (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 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Table_102_0_56, 67, -1, G__defined_typename("Char_t"), 0, 4, 1, 1, 9, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 '10' rownumber "
"C - 'Char_t' 10 '\"\"' colfirst C - 'Char_t' 10 '\"\"' collast", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("PrintContents",1371,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintHeader",1110,G__G__Table_102_0_58, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Project",727,G__G__Table_102_0_59, 121, -1, -1, 0, 6, 1, 1, 0, 
"C - - 10 - hname C - - 10 - varexp "
"C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
"i - 'Int_t' 0 '1000000000' nentries i - 'Int_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Purge",515,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReAllocate",988,G__G__Table_102_0_61, 89, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReAllocate",988,G__G__Table_102_0_62, 89, -1, -1, 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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Table_102_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Table_102_0_65, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Char_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNRows",805,G__G__Table_102_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Table_102_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetMap",801,G__G__Table_102_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' wipe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set h - 'UInt_t' 0 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Table_102_0_71, 89, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_102_0_72, 89, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColumnIndex",1414,G__G__Table_102_0_73, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 - columnName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnName",1295,G__G__Table_102_0_74, 67, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIndexArray",1303,G__G__Table_102_0_75, 72, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberOfColumns",1823,G__G__Table_102_0_76, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOffset",903,G__G__Table_102_0_77, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOffset",903,G__G__Table_102_0_78, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnSize",1321,G__G__Table_102_0_79, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnSize",1321,G__G__Table_102_0_80, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeSize",1117,G__G__Table_102_0_81, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeSize",1117,G__G__Table_102_0_82, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDimensions",1337,G__G__Table_102_0_83, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDimensions",1337,G__G__Table_102_0_84, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnType",1328,G__G__Table_102_0_85, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnType",1328,G__G__Table_102_0_86, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType), -1, 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumnComment",1633,G__G__Table_102_0_87, 67, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - columnIndex", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,G__G__Table_102_0_88, 67, -1, -1, 0, 1, 3, 1, 1, "i 'TTable::EColumnType' - 0 - type", (char*)NULL, (void*) G__func2void( (const char* (*)(TTable::EColumnType))(&TTable::GetTypeName) ), 0);
   G__memfunc_setup("GetTypeId",879,G__G__Table_102_0_89, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType), -1, 0, 1, 3, 1, 0, "C - - 10 - typeName", (char*)NULL, (void*) G__func2void( (TTable::EColumnType (*)(const char*))(&TTable::GetTypeId) ), 0);
   G__memfunc_setup("TableDictionary",1534,G__G__Table_102_0_90, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable::TableDictionary) ), 0);
   G__memfunc_setup("Class",502,G__G__Table_102_0_91, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_102_0_92, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_102_0_93, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_102_0_94, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_102_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_102_0_99, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_102_0_100, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_102_0_101, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_102_0_102, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTable", 698, G__G__Table_102_0_103, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDataSetIter(void) {
   /* TDataSetIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSetIter));
   G__memfunc_setup("NextDataSet",1093,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 2, 0, "u 'TIter' - 1 - next", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextDataSet",1093,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - nDataSet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNullSet",999,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 2, 0, "", "return a fake pointer == -1 casted to (TDataSet *)", (void*) NULL, 0);
   G__memfunc_setup("TDataSetIter",1166,G__G__Table_138_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSetIter), -1, 0, 3, 1, 1, 0, 
"U 'TDataSet' - 0 '0' l i - 'Int_t' 0 '1' depth "
"g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataSetIter",1166,G__G__Table_138_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSetIter), -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - l g - 'Bool_t' 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Table_138_0_6, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Table_138_0_7, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set C - 'Char_t' 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Table_138_0_8, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cd",167,G__G__Table_138_0_9, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - dirname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cd",167,G__G__Table_138_0_10, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - ds", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Table_138_0_11, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "u 'TDataSet::EDataSetPass' 'TDataSet::EDataSetPass' 0 'TDataSet::kContinue' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Table_138_0_12, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Table_138_0_13, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDepth",789,G__G__Table_138_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cwd",286,G__G__Table_138_0_15, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dir",287,G__G__Table_138_0_16, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 0 - dirname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Du",185,G__G__Table_138_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "summarize dataset usage", (void*) NULL, 1);
   G__memfunc_setup("Df",170,G__G__Table_138_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "report number of free \"table\" blocks.", (void*) NULL, 1);
   G__memfunc_setup("Find",385,G__G__Table_138_0_19, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 4, 1, 1, 0, 
"C - 'Char_t' 10 - path U 'TDataSet' - 0 '0' rootset "
"g - 'Bool_t' 0 'kFALSE' mkdir g - 'Bool_t' 0 'kFALSE' titleFlag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByPath",969,G__G__Table_138_0_20, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - path U 'TDataSet' - 0 '0' rootset "
"g - 'Bool_t' 0 'kFALSE' mkdir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindDataSet",1063,G__G__Table_138_0_21, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - name C - 'Char_t' 10 '\"\"' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByName",957,G__G__Table_138_0_22, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - name C - 'Char_t' 10 '\"\"' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByTitle",1086,G__G__Table_138_0_23, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - title C - 'Char_t' 10 '\"\"' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindDataSet",1063,G__G__Table_138_0_24, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"U 'TDataSet' - 0 - set C - 'Char_t' 10 - path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByPointer",1309,G__G__Table_138_0_25, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"U 'TDataSet' - 0 - set C - 'Char_t' 10 '0' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 8, "C - 'Char_t' 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Flag",378,G__G__Table_138_0_28, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 'TDataSet::kMark' flag i 'TDataSet::EBitOpt' - 0 'TDataSet::kSet' reset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Flag",378,G__G__Table_138_0_29, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - path h - 'UInt_t' 0 'TDataSet::kMark' flag "
"i 'TDataSet::EBitOpt' - 0 'TDataSet::kSet' reset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Flag",378,G__G__Table_138_0_30, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset h - 'UInt_t' 0 'TDataSet::kMark' flag "
"i 'TDataSet::EBitOpt' - 0 'TDataSet::kSet' reset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Ls",191,G__G__Table_138_0_31, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 8, 
"C - 'Char_t' 10 '\"\"' dirname C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Ls",191,G__G__Table_138_0_32, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 8, 
"C - 'Char_t' 10 - dirname i - 'Int_t' 0 - depth", (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 '\"\"' dirname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,G__G__Table_138_0_34, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 8, 
"u 'TString' - 0 - dirname C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,G__G__Table_138_0_35, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 8, 
"C - 'Char_t' 10 - dirname i - 'Int_t' 0 - depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mkdir",503,G__G__Table_138_0_36, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - dirname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Md",177,G__G__Table_138_0_37, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - dirname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Path",397,G__G__Table_138_0_38, 117, G__get_linked_tagnum(&G__G__TableLN_TString), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Path",397,G__G__Table_138_0_39, 117, G__get_linked_tagnum(&G__G__TableLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pwd",299,G__G__Table_138_0_40, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rmdir",510,G__G__Table_138_0_41, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rmdir",510,G__G__Table_138_0_42, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - dirname C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rd",182,G__G__Table_138_0_43, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - dirname C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shunt",530,G__G__Table_138_0_44, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shunt",530,G__G__Table_138_0_45, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set C - 'Char_t' 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shunt",530,G__G__Table_138_0_46, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Table_138_0_47, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "u 'TDataSet::EDataSetPass' 'TDataSet::EDataSetPass' 0 'TDataSet::kContinue' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Table_138_0_48, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - path U 'TDataSet' - 0 '0' rootset "
"g - 'Bool_t' 0 'kFALSE' mkdir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,G__G__Table_138_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,G__G__Table_138_0_51, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Table_138_0_52, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 '0' l i - 'Int_t' 0 '0' depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator*",918,G__G__Table_138_0_53, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_138_0_54, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDataSetIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_138_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_138_0_56, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDataSetIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_138_0_57, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDataSetIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_138_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_138_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_138_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSetIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_138_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_138_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSetIter::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDataSetIter", 1166, G__G__Table_138_0_66, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TDataSetIter), -1, 0, 1, 1, 1, 0, "u 'TDataSetIter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDataSetIter", 1292, G__G__Table_138_0_67, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Table_138_0_68, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TDataSetIter), -1, 1, 1, 1, 1, 0, "u 'TDataSetIter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDataSet(void) {
   /* TDataSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TDataSet));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TDataSet' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMother",923,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - mother", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDataSet",762,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 2, 0, 
"C - - 10 - name C - - 10 - title", "to support TDictionary", (void*) NULL, 0);
   G__memfunc_setup("AddMain",654,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDataSet' - 0 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortIt",613,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass), G__defined_typename("TDataSet::EDataSetPass"), 0, 1, 3, 2, 0, "U 'TDataSet' - 0 - ds", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortIt",613,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass), G__defined_typename("TDataSet::EDataSetPass"), 0, 2, 3, 2, 0, 
"U 'TDataSet' - 0 - ds Y - - 0 - user", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRealParent",1294,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCollection",1418,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataSet",762,G__G__Table_139_0_9, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 0, 
"C - - 10 '\"\"' name U 'TDataSet' - 0 '0' parent "
"g - 'Bool_t' 0 'kFALSE' arrayFlag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataSet",762,G__G__Table_139_0_10, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 2, 1, 1, 0, 
"u 'TDataSet' - 11 - src u 'TDataSet::EDataSetPass' 'TDataSet::EDataSetPass' 0 'kAll' iopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDataSet",762,G__G__Table_139_0_11, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "u 'TNode' - 1 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Table_139_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,G__G__Table_139_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset i - 'Int_t' 0 '0' idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtAndExpand",1329,G__G__Table_139_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset i - 'Int_t' 0 '0' idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,G__G__Table_139_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,G__G__Table_139_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__G__Table_139_0_17, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Find",385,G__G__Table_139_0_21, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 8, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByName",957,G__G__Table_139_0_22, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 8, 
"C - - 10 - name C - - 10 '\"\"' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByPath",969,G__G__Table_139_0_23, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 8, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindByTitle",1086,G__G__Table_139_0_24, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 3, 1, 1, 8, 
"C - - 10 - title C - - 10 '\"\"' path "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,G__G__Table_139_0_27, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjArray",1082,G__G__Table_139_0_28, 85, G__get_linked_tagnum(&G__G__TableLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,G__G__Table_139_0_29, 85, G__get_linked_tagnum(&G__G__TableLN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetList",700,G__G__Table_139_0_30, 85, G__get_linked_tagnum(&G__G__TableLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListSize",1111,G__G__Table_139_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMainSet",977,G__G__Table_139_0_32, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TDataSet* (*)())(&TDataSet::GetMainSet) ), 0);
   G__memfunc_setup("GetMother",911,G__G__Table_139_0_33, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Table_139_0_34, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParent",906,G__G__Table_139_0_35, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasData",662,G__G__Table_139_0_36, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", "Check whether this dataset has extra \"data-members\"", (void*) NULL, 1);
   G__memfunc_setup("Instance",821,G__G__Table_139_0_37, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("instance",853,G__G__Table_139_0_38, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TDataSet* (*)())(&TDataSet::instance) ), 0);
   G__memfunc_setup("Path",397,G__G__Table_139_0_39, 117, G__get_linked_tagnum(&G__G__TableLN_TString), -1, 0, 0, 1, 1, 8, "", "return the \"full\" path of this dataset", (void*) NULL, 1);
   G__memfunc_setup("Pass",407,G__G__Table_139_0_40, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass), G__defined_typename("TDataSet::EDataSetPass"), 0, 2, 1, 1, 0, 
"1 - 'TDataSet::EDataSetPass (*)(TDataSet*)' 0 - callback i - 'Int_t' 0 '0' depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pass",407,G__G__Table_139_0_41, 105, G__get_linked_tagnum(&G__G__TableLN_TDataSetcLcLEDataSetPass), G__defined_typename("TDataSet::EDataSetPass"), 0, 3, 1, 1, 0, 
"1 - 'TDataSet::EDataSetPass (*)(TDataSet*,void*)' 0 - callback Y - - 0 - user "
"i - 'Int_t' 0 '0' depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintContents",1371,G__G__Table_139_0_42, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Purge",515,G__G__Table_139_0_43, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Table_139_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAt",803,G__G__Table_139_0_45, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMother",923,G__G__Table_139_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 '0' parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Table_139_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__Table_139_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 '0' parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWrite",823,G__G__Table_139_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shunt",530,G__G__Table_139_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 '0' newParent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Table_139_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", "Sort objects in lexical order", (void*) NULL, 1);
   G__memfunc_setup("IsEmpty",715,G__G__Table_139_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMarked",784,G__G__Table_139_0_54, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsThisDir",883,G__G__Table_139_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"C - - 10 - dirname i - - 0 '-1' len "
"i - - 0 '0' ignorecase", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,G__G__Table_139_0_56, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 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", "Option \"*\" means print all levels", (void*) NULL, 1);
   G__memfunc_setup("ls",223,G__G__Table_139_0_58, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - depth", "Print the \"depth\" levels of this datatset", (void*) NULL, 1);
   G__memfunc_setup("Mark",395,G__G__Table_139_0_59, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("UnMark",590,G__G__Table_139_0_60, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("MarkAll",676,G__G__Table_139_0_61, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("UnMarkAll",871,G__G__Table_139_0_62, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("InvertAllMarks",1423,G__G__Table_139_0_63, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Mark",395,G__G__Table_139_0_64, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - flag i 'TDataSet::EBitOpt' - 0 'kSet' reset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Table_139_0_65, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Prev",413,G__G__Table_139_0_66, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Table_139_0_67, 121, -1, -1, 0, 0, 1, 1, 0, "", "Update dataset", (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Table_139_0_68, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set h - 'UInt_t' 0 '0' opt", "Update this dataset with the new one", (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_139_0_71, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDataSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_139_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_139_0_73, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDataSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_139_0_74, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDataSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_139_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_139_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_139_0_80, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_139_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_139_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDataSet", 888, G__G__Table_139_0_83, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTableDescriptor(void) {
   /* TTableDescriptor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TClass' - 0 - classPtr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCommentsSetName",1823,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "C - - 10 '\".comments\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 1, 1, 1, 0, "U 'TTable' - 10 - parentTable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - classPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 1, 1, 1, 0, "u 'TTableDescriptor' - 11 - dsc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "Y - - 10 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 10 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,G__G__Table_144_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'tableDescriptor_st' - 11 - element C - - 10 - comment "
"i - 'Int_t' 0 - indx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset i - 'Int_t' 0 '0' idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateLeafList",1384,G__G__Table_144_0_10, 117, G__get_linked_tagnum(&G__G__TableLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LearnTable",986,G__G__Table_144_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTable' - 10 - parentTable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LearnTable",986,G__G__Table_144_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - classPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColumnName",1007,G__G__Table_144_0_13, 67, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColumnByName",1194,G__G__Table_144_0_14, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumberOfColumns",1535,G__G__Table_144_0_15, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IndexArray",1015,G__G__Table_144_0_16, 72, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Offset",615,G__G__Table_144_0_17, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Offset",615,G__G__Table_144_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColumnSize",1033,G__G__Table_144_0_19, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColumnSize",1033,G__G__Table_144_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TypeSize",829,G__G__Table_144_0_21, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TypeSize",829,G__G__Table_144_0_22, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dimensions",1049,G__G__Table_144_0_23, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dimensions",1049,G__G__Table_144_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColumnType",1040,G__G__Table_144_0_25, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColumnType",1040,G__G__Table_144_0_26, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLEColumnType), -1, 0, 1, 1, 1, 8, "C - 'Char_t' 10 '0' columnName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RowClass",814,G__G__Table_144_0_27, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOffset",915,G__G__Table_144_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - offset i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSize",711,G__G__Table_144_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - size i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTypeSize",1129,G__G__Table_144_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - size i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,G__G__Table_144_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - dim i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColumnType",1340,G__G__Table_144_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'TTable::EColumnType' - 0 - type i - 'Int_t' 0 - column", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateOffsets",1341,G__G__Table_144_0_34, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TTableDescriptor' - 10 - newDesciptor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeDescriptor",1437,G__G__Table_144_0_35, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 1, 3, 1, 0, "C - - 10 - structName", (char*)NULL, (void*) G__func2void( (TTableDescriptor* (*)(const char*))(&TTableDescriptor::MakeDescriptor) ), 0);
   G__memfunc_setup("MakeCommentField",1589,G__G__Table_144_0_36, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' createFlag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDescriptorPointer",2080,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDescriptorPointer",2092,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TTableDescriptor' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_39, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_40, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_41, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableDescriptor",1627,G__G__Table_144_0_42, 105, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTable",776,G__G__Table_144_0_43, 85, G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_144_0_44, 117, G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_144_0_45, 117, G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Table_144_0_46, 85, G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Table_144_0_47, 85, G__get_linked_tagnum(&G__G__TableLN_tableDescriptor_st), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TableDictionary",1534,G__G__Table_144_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableDescriptor::TableDictionary) ), 0);
   G__memfunc_setup("Class",502,G__G__Table_144_0_49, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTableDescriptor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_144_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableDescriptor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_144_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTableDescriptor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_144_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTableDescriptor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_144_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_144_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableDescriptor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_144_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableDescriptor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_144_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableDescriptor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_144_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableDescriptor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTableDescriptor", 1753, G__G__Table_144_0_61, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTableMap(void) {
   /* TTableMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTableMap));
   G__memfunc_setup("TTableMap",858,G__G__Table_146_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TTableMap), -1, 0, 1, 1, 1, 0, "U 'TTable' - 10 '0' table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableMap",858,G__G__Table_146_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TTableMap), -1, 0, 1, 1, 1, 0, "u 'TTableMap' - 11 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Table_146_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Push_back",912,G__G__Table_146_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - next", "workaround for Cint", (void*) NULL, 0);
   G__memfunc_setup("Table",488,G__G__Table_146_0_6, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Begin",485,G__G__Table_146_0_7, 117, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Begin",485,G__G__Table_146_0_8, 117, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("End",279,G__G__Table_146_0_9, 117, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("End",279,G__G__Table_146_0_10, 117, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_146_0_11, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTableMap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_146_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableMap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_146_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTableMap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_146_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTableMap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_146_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__Table_146_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableMap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_146_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableMap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_146_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableMap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_146_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableMap::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTableMap", 984, G__G__Table_146_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTablecLcLiterator(void) {
   /* TTable::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Table_150_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_150_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'TTable' - 11 - table u 'vector<long,allocator<long> >::iterator' 'TTable::iterator::vec_const_iterator' 1 - arowPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_150_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TTable::iterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Table_150_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TTable::iterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_150_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_150_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_150_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_150_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Table_150_0_9, 117, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Table_150_0_10, 117, G__get_linked_tagnum(&G__G__TableLN_TTablecLcLiterator), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Table_150_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Table_150_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rowPtr",654,G__G__Table_150_0_13, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator void*",1384,G__G__Table_150_0_14, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Table_150_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "u 'TTable::iterator' - 11 - it", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Table_150_0_16, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Table_150_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TTable::iterator' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Table_150_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TTable::iterator' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Table",488,G__G__Table_150_0_19, 117, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RowSize",723,G__G__Table_150_0_20, 108, -1, G__defined_typename("Long_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Table_150_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTChair(void) {
   /* TChair */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TChair));
   G__memfunc_setup("GetThisTable",1184,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThisTable",1184,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffset",903,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - base k - 'ULong_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TChair",571,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TChair), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TChair",571,G__G__Table_155_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TChair), -1, 0, 1, 1, 1, 0, "U 'TTable' - 0 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TChair",571,G__G__Table_155_0_6, 105, G__get_linked_tagnum(&G__G__TableLN_TChair), -1, 0, 1, 1, 1, 0, "u 'TChair' - 11 - org", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Table_155_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n Y - - 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - dataset i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,G__G__Table_155_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 10 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__G__Table_155_0_10, 89, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopySet",711,G__G__Table_155_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TChair' - 1 - chair", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyRows",838,G__G__Table_155_0_13, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"U 'TChair' - 10 - srcChair i - 'Int_t' 0 '0' srcRow "
"i - 'Int_t' 0 '0' dstRow i - 'Int_t' 0 '0' nRows "
"g - 'Bool_t' 0 'kFALSE' expand", (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 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Table_155_0_15, 85, G__get_linked_tagnum(&G__G__TableLN_TH1), -1, 0, 5, 1, 1, 0, 
"u 'TCut' - 0 - varexp u 'TCut' - 0 - selection "
"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Table_155_0_16, 85, G__get_linked_tagnum(&G__G__TableLN_TH1), -1, 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArray",799,G__G__Table_155_0_17, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowClass",1102,G__G__Table_155_0_18, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNRows",793,G__G__Table_155_0_19, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowSize",1011,G__G__Table_155_0_20, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableSize",1187,G__G__Table_155_0_21, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Table",488,G__G__Table_155_0_22, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowDescriptors",1770,G__G__Table_155_0_23, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Table_155_0_24, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Table_155_0_25, 121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - formula C - - 10 - varexp "
"C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption i - 'Int_t' 0 '1000000000' nentries "
"i - 'Int_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasData",662,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("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("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - deep", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NaN",253,G__G__Table_155_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeExpression",1454,G__G__Table_155_0_31, 67, -1, G__defined_typename("Char_t"), 0, 2, 1, 1, 0, 
"C - 'Char_t' 12 - expressions i - 'Int_t' 0 - nExpressions", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Table_155_0_32, 67, -1, G__defined_typename("Char_t"), 0, 2, 1, 1, 8, 
"C - 'Char_t' 0 - buf i - 'Int_t' 0 - n", (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 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Table_155_0_34, 67, -1, G__defined_typename("Char_t"), 0, 4, 1, 1, 9, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 '10' rownumber "
"C - 'Char_t' 10 '\"\"' colfirst C - 'Char_t' 10 '\"\"' collast", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintHeader",1110,G__G__Table_155_0_35, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Purge",515,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReAllocate",988,G__G__Table_155_0_37, 89, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReAllocate",988,G__G__Table_155_0_38, 89, -1, -1, 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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Table_155_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Table_155_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Char_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNRows",805,G__G__Table_155_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Table_155_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 - set h - 'UInt_t' 0 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Table_155_0_46, 89, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_155_0_47, 89, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_155_0_48, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TChair::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_155_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChair::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_155_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TChair::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_155_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TChair::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_155_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_155_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChair::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_155_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TChair::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_155_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChair::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_155_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TChair::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TChair", 697, G__G__Table_155_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTColumnView(void) {
   /* TColumnView */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TColumnView));
   G__memfunc_setup("TColumnView",1117,G__G__Table_156_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TColumnView), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"\"' colName U 'TTable' - 0 '0' table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Histogram",942,G__G__Table_156_0_3, 85, G__get_linked_tagnum(&G__G__TableLN_TH1), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' selection", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_156_0_5, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TColumnView::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_156_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TColumnView::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_156_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TColumnView::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_156_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TColumnView::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_156_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__Table_156_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TColumnView::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_156_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TColumnView::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_156_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TColumnView::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_156_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TColumnView::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TColumnView", 1117, G__G__Table_156_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TColumnView), -1, 0, 1, 1, 1, 0, "u 'TColumnView' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TColumnView", 1243, G__G__Table_156_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFileIter(void) {
   /* TFileIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TFileIter));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TableLN_TIterator), -1, 1, 1, 1, 4, 0, "u 'TIterator' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 4, 8, "u 'TIterator' - 11 - it", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadObj",663,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 2, 8, "U 'TKey' - 10 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreFileScope",1630,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveFileScope",1289,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextEventKey",1226,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TKey), -1, 0, 3, 1, 2, 0, 
"h - 'UInt_t' 0 'UInt_t(-1)' eventNumber h - 'UInt_t' 0 'UInt_t(-1)' runNumber "
"C - - 10 '\"*\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileIter",872,G__G__Table_192_0_8, 105, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' option "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress "
"i - 'Int_t' 0 '0' netopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileIter",872,G__G__Table_192_0_9, 105, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 '0' file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileIter",872,G__G__Table_192_0_10, 105, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - directory", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileIter",872,G__G__Table_192_0_11, 105, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 0, 1, 1, 1, 0, "u 'TFileIter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CurrentCursorPosition",2230,G__G__Table_192_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTFile",756,G__G__Table_192_0_13, 85, G__get_linked_tagnum(&G__G__TableLN_TFile), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTDirectory",1321,G__G__Table_192_0_14, 85, G__get_linked_tagnum(&G__G__TableLN_TDirectory), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapName",671,G__G__Table_192_0_15, 117, G__get_linked_tagnum(&G__G__TableLN_TString), -1, 0, 3, 3, 1, 0, 
"C - - 10 - name C - - 10 '0' localSystemKey "
"C - - 10 '0' mountedFileSystemKey", (char*)NULL, (void*) G__func2void( (TString (*)(const char*, const char*, const char*))(&TFileIter::MapName) ), 0);
   G__memfunc_setup("GetResourceName",1513,G__G__Table_192_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::GetResourceName) ), 0);
   G__memfunc_setup("GetDefaultMapFileName",2052,G__G__Table_192_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::GetDefaultMapFileName) ), 0);
   G__memfunc_setup("GetLocalFileNameKey",1845,G__G__Table_192_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::GetLocalFileNameKey) ), 0);
   G__memfunc_setup("GetForeignFileSystemKey",2328,G__G__Table_192_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::GetForeignFileSystemKey) ), 0);
   G__memfunc_setup("PurgeKeys",927,G__G__Table_192_0_20, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TList' - 0 - listOfKeys", (char*)NULL, (void*) G__func2void( (void (*)(TList*))(&TFileIter::PurgeKeys) ), 0);
   G__memfunc_setup("IsOpen",590,G__G__Table_192_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextEventGet",1217,G__G__Table_192_0_22, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 'UInt_t(-1)' eventNumber h - 'UInt_t' 0 'UInt_t(-1)' runNumber "
"C - - 10 '\"*\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextEventPut",1242,G__G__Table_192_0_23, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - eventNum "
"h - 'UInt_t' 0 - runNumber C - - 10 '0' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCursorPosition",1791,G__G__Table_192_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - cursorPosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCursorPosition",1791,G__G__Table_192_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - keyNameToFind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjlen",890,G__G__Table_192_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TotalKeys",928,G__G__Table_192_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SkipObjects",1121,G__G__Table_192_0_28, 85, G__get_linked_tagnum(&G__G__TableLN_TKey), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' nSkip", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObject",887,G__G__Table_192_0_29, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDepth",789,G__G__Table_192_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentKey",1324,G__G__Table_192_0_31, 85, G__get_linked_tagnum(&G__G__TableLN_TKey), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeyName",970,G__G__Table_192_0_32, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Table_192_0_33, 117, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - cursorPosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Table_192_0_34, 117, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 1, 1, 1, 1, 0, "C - - 10 - keyNameToFind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Table_192_0_35, 117, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Table_192_0_36, 117, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_192_0_37, 117, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_192_0_38, 117, G__get_linked_tagnum(&G__G__TableLN_TFileIter), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator const char*",1947,G__G__Table_192_0_40, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const TFile*",2001,G__G__Table_192_0_41, 85, G__get_linked_tagnum(&G__G__TableLN_TFile), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const TDirectory*",2566,G__G__Table_192_0_42, 85, G__get_linked_tagnum(&G__G__TableLN_TDirectory), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator int",1239,G__G__Table_192_0_43, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Table_192_0_44, 105, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Table_192_0_45, 105, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Table_192_0_47, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nSkip", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rewind",617,G__G__Table_192_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Table_192_0_50, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nSkip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Table_192_0_51, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_192_0_52, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_192_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_192_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_192_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_192_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_192_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_192_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_192_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_192_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFileIter", 998, G__G__Table_192_0_64, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFileSet(void) {
   /* TFileSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TFileSet));
   G__memfunc_setup("TFileSet",768,G__G__Table_193_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TFileSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFileSet",768,G__G__Table_193_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TFileSet), -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - dirname C - 'Char_t' 10 '0' filename "
"g - 'Bool_t' 0 'kTRUE' expand i - 'Int_t' 0 '10' maxDepth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasData",662,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEmpty",715,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_193_0_6, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_193_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_193_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_193_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_193_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_193_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_193_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_193_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_193_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileSet::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFileSet", 768, G__G__Table_193_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TFileSet), -1, 0, 1, 1, 1, 0, "u 'TFileSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFileSet", 894, G__G__Table_193_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGenericTable(void) {
   /* TGenericTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTable));
   G__memfunc_setup("GetDescriptorPointer",2080,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDescriptorPointer",2092,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TTableDescriptor' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGenericType",1419,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 2, 1, 1, 0, 
"C - - 10 - structName C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_6, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 2, 1, 1, 0, 
"C - - 10 - structName i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_7, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 3, 1, 1, 0, 
"C - - 10 - structName C - - 10 - name "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_8, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 2, 1, 1, 0, 
"u 'TTableDescriptor' - 11 - dsc C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_9, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 2, 1, 1, 0, 
"u 'TTableDescriptor' - 11 - dsc i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGenericTable",1273,G__G__Table_194_0_10, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 3, 1, 1, 0, 
"u 'TTableDescriptor' - 11 - dsc C - - 10 - name "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTable",776,G__G__Table_194_0_11, 67, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTableDescriptors",1946,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowDescriptors",1770,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Table_194_0_14, 99, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_194_0_15, 99, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Table_194_0_16, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Table_194_0_17, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Table_194_0_18, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Table_194_0_19, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_194_0_20, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGenericTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_194_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGenericTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_194_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGenericTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_194_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGenericTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_194_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__Table_194_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGenericTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_194_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGenericTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_194_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGenericTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_194_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGenericTable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGenericTable", 1273, G__G__Table_194_0_32, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TGenericTable), -1, 0, 1, 1, 1, 0, "u 'TGenericTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGenericTable", 1399, G__G__Table_194_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGenericTablecLcLiterator(void) {
   /* TGenericTable::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator));
   G__memfunc_setup("iterator",874,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_195_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - size c - - 1 - rowPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_195_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'TTable' - 11 - t c - - 1 - rowPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_195_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TTable' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_195_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TGenericTable::iterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Table_195_0_6, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 1, 1, 1, 1, 0, "u 'TGenericTable::iterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_195_0_7, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_195_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_195_0_9, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_195_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Table_195_0_11, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Table_195_0_12, 117, G__get_linked_tagnum(&G__G__TableLN_TGenericTablecLcLiterator), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Table_195_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "u 'TGenericTable::iterator' - 11 - it", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Table_195_0_14, 67, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Table_195_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGenericTable::iterator' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Table_195_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGenericTable::iterator' - 11 - t", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Table_195_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTIndexTable(void) {
   /* TIndexTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTable));
   G__memfunc_setup("TIndexTable",1076,G__G__Table_196_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTable), -1, 0, 1, 1, 1, 0, "U 'TTable' - 10 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIndexTable",1076,G__G__Table_196_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTable), -1, 0, 1, 1, 1, 0, "u 'TIndexTable' - 11 - indx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTable",776,G__G__Table_196_0_3, 73, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Table_196_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Table_196_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - next", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Table",488,G__G__Table_196_0_6, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Table_196_0_7, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Table_196_0_8, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Table_196_0_9, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Table_196_0_10, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateDescriptor",1651,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDescriptorPointer",2080,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TTableDescriptor), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDescriptorPointer",2092,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TTableDescriptor' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TIndexTable",1076,G__G__Table_196_0_14, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIndexTable",1076,G__G__Table_196_0_15, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTable), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIndexTable",1076,G__G__Table_196_0_16, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTable), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIndexTable",1076,G__G__Table_196_0_17, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTable), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTable",776,G__G__Table_196_0_18, 73, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_196_0_19, 105, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_196_0_20, 105, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_196_0_21, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TIndexTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_196_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIndexTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_196_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TIndexTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_196_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TIndexTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_196_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__Table_196_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIndexTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_196_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TIndexTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_196_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIndexTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_196_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TIndexTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TIndexTable", 1202, G__G__Table_196_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTIndexTablecLcLiterator(void) {
   /* TIndexTable::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator));
   G__memfunc_setup("iterator",874,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_197_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'TTable' - 11 - t i - - 11 - rowPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_197_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TTable' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Table_197_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TIndexTable::iterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Table_197_0_5, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 1, 1, 1, 1, 0, "u 'TIndexTable::iterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_197_0_6, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Table_197_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_197_0_8, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Table_197_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Table_197_0_10, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Table_197_0_11, 117, G__get_linked_tagnum(&G__G__TableLN_TIndexTablecLcLiterator), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Table_197_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "u 'TIndexTable::iterator' - 11 - it", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Table_197_0_13, 89, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator int",1239,G__G__Table_197_0_14, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Table_197_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TIndexTable::iterator' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Table_197_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TIndexTable::iterator' - 11 - t", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Table_197_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObjectSet(void) {
   /* TObjectSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TObjectSet));
   G__memfunc_setup("TObjectSet",983,G__G__Table_198_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TObjectSet), -1, 0, 3, 1, 1, 0, 
"C - 'Char_t' 10 - name U 'TObject' - 0 '0' obj "
"g - 'Bool_t' 0 'kTRUE' makeOwner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjectSet",983,G__G__Table_198_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TObjectSet), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 '0' obj g - 'Bool_t' 0 'kTRUE' makeOwner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddObject",864,G__G__Table_198_0_3, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kTRUE' makeOwner", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoOwner",702,G__G__Table_198_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' done", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasData",662,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObject",887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Instance",821,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOwner",711,G__G__Table_198_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Table_198_0_12, 85, G__get_linked_tagnum(&G__G__TableLN_TObject), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - makeOwner", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("instance",853,G__G__Table_198_0_13, 85, G__get_linked_tagnum(&G__G__TableLN_TObjectSet), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObjectSet* (*)())(&TObjectSet::instance) ), 0);
   G__memfunc_setup("Class",502,G__G__Table_198_0_14, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TObjectSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_198_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjectSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_198_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TObjectSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_198_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TObjectSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_198_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__Table_198_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjectSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_198_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjectSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_198_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjectSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_198_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjectSet::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TObjectSet", 983, G__G__Table_198_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TObjectSet), -1, 0, 1, 1, 1, 0, "u 'TObjectSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TObjectSet", 1109, G__G__Table_198_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPoints3D(void) {
   /* TPoints3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TPoints3D));
   G__memfunc_setup("IsOwner",711,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOwner",702,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' done", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints3D",840,G__G__Table_201_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TPoints3D), -1, 0, 1, 1, 1, 0, "U 'TPoints3DABC' - 0 '0' points", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints3D",840,G__G__Table_201_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TPoints3D), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints3D",840,G__G__Table_201_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TPoints3D), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints3D",840,G__G__Table_201_0_6, 105, G__get_linked_tagnum(&G__G__TableLN_TPoints3D), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y F - 'Float_t' 0 - z "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoints3D",840,G__G__Table_201_0_7, 105, G__get_linked_tagnum(&G__G__TableLN_TPoints3D), -1, 0, 1, 1, 1, 0, "u 'TPoints3D' - 11 - points", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,G__G__Table_201_0_10, 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("GetLastPosition",1545,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetP",368,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetY",377,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZ",378,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 8, 
"F - 'Float_t' 0 - xyz i - 'Int_t' 0 - idx "
"i - 'Int_t' 0 '1' num", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 1, "i - 'Int_t' 0 - idx", (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("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("PaintPoints",1145,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - F - 'Float_t' 0 - - "
"C - 'Option_t' 10 - -", (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("SetLastPosition",1557,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - point f - 'Float_t' 0 - x "
"f - 'Float_t' 0 - y f - 'Float_t' 0 - z", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 '0' p "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_201_0_30, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPoints3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_201_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_201_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPoints3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_201_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPoints3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_201_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__Table_201_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_201_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPoints3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_201_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_201_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPoints3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPoints3D", 966, G__G__Table_201_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__Table_201_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TPoints3D), -1, 1, 1, 1, 1, 0, "u 'TPoints3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPointsArray3D(void) {
   /* TPointsArray3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D));
   G__memfunc_setup("TPointsArray3D",1351,G__G__Table_203_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPointsArray3D",1351,G__G__Table_203_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPointsArray3D",1351,G__G__Table_203_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPointsArray3D",1351,G__G__Table_203_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y F - 'Float_t' 0 - z "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPointsArray3D",1351,G__G__Table_203_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D), -1, 0, 1, 1, 1, 0, "u 'TPointsArray3D' - 11 - points", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - points", (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("GetLastPosition",1545,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetP",368,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetY",377,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZ",378,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 8, 
"F - 'Float_t' 0 - xyz i - 'Int_t' 0 - idx "
"i - 'Int_t' 0 '1' num", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 1, "i - 'Int_t' 0 - idx", (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("Is3D",307,G__G__Table_203_0_18, 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("PaintPoints",1145,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - F - 'Float_t' 0 - - "
"C - 'Option_t' 10 - -", (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("SetLastPosition",1557,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - point f - 'Float_t' 0 - x "
"f - 'Float_t' 0 - y f - 'Float_t' 0 - z", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 '0' p "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_203_0_27, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPointsArray3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_203_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointsArray3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_203_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPointsArray3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_203_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPointsArray3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_203_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__Table_203_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointsArray3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_203_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPointsArray3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_203_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointsArray3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_203_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPointsArray3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPointsArray3D", 1477, G__G__Table_203_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__Table_203_0_40, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TPointsArray3D), -1, 1, 1, 1, 1, 0, "u 'TPointsArray3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPolyLineShape(void) {
   /* TPolyLineShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape));
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateX3DSize",1214,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN__x3d_sizeof_), G__defined_typename("Size3D"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kFALSE' marker", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConnection",1340,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TShape' - 0 - connection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PointDistancetoPrimitive",2513,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TPolyLineShape",1393,G__G__Table_208_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyLineShape",1393,G__G__Table_208_0_6, 105, G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape), -1, 0, 2, 1, 1, 0, 
"U 'TPoints3DABC' - 0 - points C - 'Option_t' 10 '\"P\"' option", (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 '\"\"' opt", (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("GetConnection",1328,G__G__Table_208_0_10, 85, G__get_linked_tagnum(&G__G__TableLN_TShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColorAttribute",1747,G__G__Table_208_0_11, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSizeAttribute",1647,G__G__Table_208_0_14, 102, -1, G__defined_typename("Size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStyleAttribute",1765,G__G__Table_208_0_15, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (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("GetMarker",898,G__G__Table_208_0_17, 85, G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPoints",925,G__G__Table_208_0_18, 85, G__get_linked_tagnum(&G__G__TableLN_TPoints3DABC), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShape",785,G__G__Table_208_0_19, 85, G__get_linked_tagnum(&G__G__TableLN_TShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSmooth",922,G__G__Table_208_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidthFactor",1407,G__G__Table_208_0_21, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintNode",898,G__G__Table_208_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 0 - start F - 'Float_t' 0 - end "
"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 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint3d",659,G__G__Table_208_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintX3DLine",1107,G__G__Table_208_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintX3DMarker",1325,G__G__Table_208_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Gyrot",533,G__G__Table_208_0_27, 68, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"D - 'Double_t' 0 - dirc d - 'Double_t' 0 - cosang "
"d - 'Double_t' 0 - sinang D - 'Double_t' 2 - trans", (char*)NULL, (void*) G__func2void( (Double_t* (*)(Double_t*, Double_t, Double_t, Double_t**))(&TPolyLineShape::Gyrot) ), 0);
   G__memfunc_setup("PaintPoints",1145,G__G__Table_208_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 '0' p "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPolyMarker",1538,G__G__Table_208_0_29, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 '0' p "
"s - 'Marker_t' 0 '0' m C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Product",737,G__G__Table_208_0_30, 102, -1, G__defined_typename("Float_t"), 0, 3, 3, 1, 0, 
"F - 'Float_t' 0 - v1 F - 'Float_t' 0 - v2 "
"i - 'Int_t' 0 '3' ndim", (char*)NULL, (void*) G__func2void( (Float_t (*)(Float_t*, Float_t*, Int_t))(&TPolyLineShape::Product) ), 0);
   G__memfunc_setup("Product",737,G__G__Table_208_0_31, 100, -1, G__defined_typename("Double_t"), 0, 3, 3, 1, 0, 
"D - 'Double_t' 0 - v1 D - 'Double_t' 0 - v2 "
"i - 'Int_t' 0 '3' ndim", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Int_t))(&TPolyLineShape::Product) ), 0);
   G__memfunc_setup("SetColorAttribute",1759,G__G__Table_208_0_32, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSizeAttribute",1659,G__G__Table_208_0_33, 102, -1, G__defined_typename("Size_t"), 0, 1, 1, 1, 0, "f - 'Size_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConnection",1340,G__G__Table_208_0_34, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i 'EShapeTypes' - 0 'kBrik' connection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShape",797,G__G__Table_208_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TShape' - 0 - shape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSmooth",934,G__G__Table_208_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' smooth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStyleAttribute",1777,G__G__Table_208_0_37, 115, -1, G__defined_typename("Style_t"), 0, 1, 1, 1, 0, "s - 'Style_t' 0 - style", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWidthFactor",1419,G__G__Table_208_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1.0' fact", "*MENU", (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__G__Table_208_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_208_0_41, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPolyLineShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_208_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLineShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_208_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPolyLineShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_208_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPolyLineShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_208_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_208_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLineShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_208_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyLineShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_208_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLineShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_208_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyLineShape::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPolyLineShape", 1393, G__G__Table_208_0_53, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape), -1, 0, 1, 1, 1, 0, "u 'TPolyLineShape' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPolyLineShape", 1519, G__G__Table_208_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Table_208_0_55, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TPolyLineShape), -1, 1, 1, 1, 1, 0, "u 'TPolyLineShape' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTResponseTable(void) {
   /* TResponseTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TResponseTable));
   G__memfunc_setup("TResponseTable",1419,G__G__Table_209_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TResponseTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TResponseTable",1419,G__G__Table_209_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TResponseTable), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - volumepath "
"C - - 10 - responseDefintion i - 'Int_t' 0 - allocSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResponse",1147,G__G__Table_209_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - track I - - 0 - nvl "
"F - - 0 - response", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindResponseLocation",2057,G__G__Table_209_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "u 'TTableDescriptor' - 1 - dsc", (char*)NULL, (void*) G__func2void( (Int_t (*)(TTableDescriptor&))(&TResponseTable::FindResponseLocation) ), 0);
   G__memfunc_setup("AddVolumePath",1294,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddResponse",1112,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - chit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - path i 'TTable::EColumnType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_209_0_8, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TResponseTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_209_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TResponseTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_209_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TResponseTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_209_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TResponseTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_209_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__Table_209_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TResponseTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_209_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TResponseTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_209_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TResponseTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_209_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TResponseTable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TResponseTable", 1419, G__G__Table_209_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TResponseTable), -1, 0, 1, 1, 1, 0, "u 'TResponseTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TResponseTable", 1545, G__G__Table_209_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTableSorter(void) {
   /* TTableSorter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTableSorter));
   G__memfunc_setup("CompareFloat_t",1424,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareInt_t",1221,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareLong_t",1322,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareULong_t",1407,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareUInt_t",1306,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareShort_t",1450,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareDouble_t",1525,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareUShort_t",1535,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareUChar_t",1389,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareChar_t",1304,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareBool_t",1318,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 12 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "Y - - 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "k - 'ULong_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "l - 'Long_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "h - 'UInt_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "s - 'Short_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "r - 'UShort_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "b - 'UChar_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "c - 'Char_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BSearch",664,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "g - 'Bool_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillIndexArray",1406,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowSize",1011,(G__InterfaceMethod) NULL, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("QSort",505,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LearnTable",986,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchFloat_t",1311,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchInt_t",1108,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchULong_t",1294,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchLong_t",1209,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchUInt_t",1193,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchShort_t",1337,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchDouble_t",1412,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchUShort_t",1422,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchUChar_t",1276,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchChar_t",1191,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchBool_t",1205,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 3, 2, 0, 
"Y - - 10 - - Y - - 12 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "k - 'ULong_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "l - 'Long_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "h - 'UInt_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "s - 'Short_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "r - 'UShort_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "b - 'UChar_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "c - 'Char_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectSearch",1206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "g - 'Bool_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSearchMethod",1507,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSimpleArray",1429,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - arraySize i - 'Int_t' 0 - firstRow "
"i - 'Int_t' 0 - numberRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildSorter",1135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TString' - 1 - colName i - 'Int_t' 0 - firstRow "
"i - 'Int_t' 0 - numberRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 2, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_54, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_55, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 4, 1, 1, 0, 
"u 'TTable' - 11 - table u 'TString' - 1 - colName "
"i - 'Int_t' 0 '0' firstRow i - 'Int_t' 0 '0' numbeRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_56, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 4, 1, 1, 0, 
"U 'TTable' - 10 - table u 'TString' - 1 - colName "
"i - 'Int_t' 0 '0' firstRow i - 'Int_t' 0 '0' numbeRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_57, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 5, 1, 1, 0, 
"u 'TTable' - 11 - table Y - 'SEARCHMETHOD' 0 - search "
"Y - 'COMPAREMETHOD' 0 - compare i - 'Int_t' 0 '0' firstRow "
"i - 'Int_t' 0 '0' numbeRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_58, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 5, 1, 1, 0, 
"U 'TTable' - 10 - table Y - 'SEARCHMETHOD' 0 - search "
"Y - 'COMPAREMETHOD' 0 - compare i - 'Int_t' 0 '0' firstRow "
"i - 'Int_t' 0 '0' numbeRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_59, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 4, 1, 1, 0, 
"F - 'Float_t' 10 - simpleArray i - 'Int_t' 0 - arraySize "
"i - 'Int_t' 0 '0' firstRow i - 'Int_t' 0 '0' numberRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_60, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 4, 1, 1, 0, 
"D - 'Double_t' 10 - simpleArray i - 'Int_t' 0 - arraySize "
"i - 'Int_t' 0 '0' firstRow i - 'Int_t' 0 '0' numberRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableSorter",1211,G__G__Table_211_0_61, 105, G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 4, 1, 1, 0, 
"L - 'Long_t' 10 - simpleArray i - 'Int_t' 0 - arraySize "
"i - 'Int_t' 0 '0' firstRow i - 'Int_t' 0 '0' numberRows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountKey",818,G__G__Table_211_0_62, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"Y - - 10 - key i - 'Int_t' 0 '0' firstIndx "
"g - 'Bool_t' 0 'kTRUE' bSearch I - 'Int_t' 0 '0' firstRow", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CountKeys",933,G__G__Table_211_0_63, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFirstKey",1202,G__G__Table_211_0_64, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "Y - - 10 - key", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_65, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_66, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_67, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "k - 'ULong_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_68, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "l - 'Long_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_69, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_70, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "s - 'Short_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_71, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_72, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "r - 'UShort_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_73, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "b - 'UChar_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_74, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "c - 'Char_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Table_211_0_75, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColumnName",1295,G__G__Table_211_0_76, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIndex",792,G__G__Table_211_0_77, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - sortedIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeyAddress",1295,G__G__Table_211_0_78, 89, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - indx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLastFound",1200,G__G__Table_211_0_79, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableName",1161,G__G__Table_211_0_80, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableTitle",1290,G__G__Table_211_0_81, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableType",1194,G__G__Table_211_0_82, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTable",776,G__G__Table_211_0_83, 85, G__get_linked_tagnum(&G__G__TableLN_TTable), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNRows",793,G__G__Table_211_0_84, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFirstRow",1120,G__G__Table_211_0_85, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Table_211_0_86, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_211_0_87, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "l - 'Long_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_211_0_88, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_211_0_89, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "Y - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Table_211_0_90, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Table_211_0_91, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Table_211_0_92, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Table_211_0_93, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_211_0_94, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTableSorter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_211_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableSorter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_211_0_96, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTableSorter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_211_0_97, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTableSorter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_211_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_211_0_102, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableSorter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_211_0_103, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableSorter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_211_0_104, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableSorter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_211_0_105, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableSorter::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTableSorter", 1211, G__G__Table_211_0_106, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TTableSorter), -1, 0, 1, 1, 1, 0, "u 'TTableSorter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTableSorter", 1337, G__G__Table_211_0_107, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTablePoints(void) {
   /* TTablePoints */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTablePoints));
   G__memfunc_setup("SetTablePointer",1525,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "Y - - 0 - table", (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("GetLastPosition",1545,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetY",377,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetZ",378,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTable",776,G__G__Table_213_0_10, 89, -1, -1, 0, 0, 1, 1, 0, "", (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("Indx",403,G__G__Table_213_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - sortedIndx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLastPosition",1557,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - f - 'Float_t' 0 - - "
"f - 'Float_t' 0 - - f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - F - 'Float_t' 0 - - "
"C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_213_0_18, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTablePoints::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_213_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTablePoints::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_213_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTablePoints::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_213_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTablePoints::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_213_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__Table_213_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTablePoints::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_213_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTablePoints::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_213_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTablePoints::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_213_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTablePoints::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTablePoints", 1335, G__G__Table_213_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTable3Points(void) {
   /* TTable3Points */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTable3Points));
   G__memfunc_setup("TTable3Points",1260,G__G__Table_214_0_1, 105, G__get_linked_tagnum(&G__G__TableLN_TTable3Points), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable3Points",1260,G__G__Table_214_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TTable3Points), -1, 0, 6, 1, 1, 0, 
"U 'TTableSorter' - 0 - sorter Y - - 10 - key "
"C - 'Char_t' 10 '\"x\"' xName C - 'Char_t' 10 '\"y\"' yName "
"C - 'Char_t' 10 '\"z\"' zName C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTable3Points",1260,G__G__Table_214_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TTable3Points), -1, 0, 6, 1, 1, 0, 
"U 'TTableSorter' - 0 - sorter i - 'Int_t' 0 - keyIndex "
"C - 'Char_t' 10 '\"x\"' xName C - 'Char_t' 10 '\"y\"' yName "
"C - 'Char_t' 10 '\"z\"' zName C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAnyColumn",1218,G__G__Table_214_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - anyName i 'TTable3Points::EPointDirection' - 0 - indx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetXColumn",1010,G__G__Table_214_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - xName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetYColumn",1011,G__G__Table_214_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - yName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetZColumn",1012,G__G__Table_214_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - zName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTotalKeys",1216,G__G__Table_214_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKey",585,G__G__Table_214_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKeyByIndx",1187,G__G__Table_214_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKeyByValue",1293,G__G__Table_214_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAnyPoint",1106,G__G__Table_214_0_12, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - idx i 'TTable3Points::EPointDirection' - 0 - xAxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetY",377,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZ",378,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPoints",1145,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - - F - - 0 - - "
"C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 8, 
"F - 'Float_t' 0 - xyz i - 'Int_t' 0 - idx "
"i - 'Int_t' 0 '1' num", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetP",368,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_214_0_21, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTable3Points::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_214_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable3Points::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_214_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTable3Points::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_214_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTable3Points::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_214_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__Table_214_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable3Points::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_214_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTable3Points::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_214_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTable3Points::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_214_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTable3Points::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTable3Points", 1260, G__G__Table_214_0_33, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TTable3Points), -1, 0, 1, 1, 1, 0, "u 'TTable3Points' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTable3Points", 1386, G__G__Table_214_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTableIter(void) {
   /* TTableIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTableIter));
   G__memfunc_setup("TTableIter",976,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableIter",976,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 1, 1, 2, 0, "u 'TTableIter' - 11 - org", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableIter",976,G__G__Table_216_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 2, 1, 1, 0, 
"U 'TTableSorter' - 10 - table f - 'Float_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableIter",976,G__G__Table_216_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 2, 1, 1, 0, 
"U 'TTableSorter' - 10 - table d - 'Double_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableIter",976,G__G__Table_216_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 2, 1, 1, 0, 
"U 'TTableSorter' - 10 - table i - 'Int_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableIter",976,G__G__Table_216_0_6, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 2, 1, 1, 0, 
"U 'TTableSorter' - 10 - table l - 'Long_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTableIter",976,G__G__Table_216_0_7, 105, G__get_linked_tagnum(&G__G__TableLN_TTableIter), -1, 0, 2, 1, 1, 0, 
"U 'TTableSorter' - 10 - table s - 'Short_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountKey",818,G__G__Table_216_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "f - 'Float_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountKey",818,G__G__Table_216_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountKey",818,G__G__Table_216_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountKey",818,G__G__Table_216_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "s - 'Short_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountKey",818,G__G__Table_216_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 1 - keyvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNRows",793,G__G__Table_216_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Table_216_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Table_216_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Table_216_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' indx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Table_216_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Table_216_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_216_0_19, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTableIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_216_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_216_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTableIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_216_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTableIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_216_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_216_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_216_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_216_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTableIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_216_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTableIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTableIter", 1102, G__G__Table_216_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTablePadView3D(void) {
   /* TTablePadView3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTablePadView3D",1379,G__G__Table_219_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D), -1, 0, 0, 1, 1, 0, "", "default ctor", (void*) NULL, 0);
   G__memfunc_setup("TTablePadView3D",1379,G__G__Table_219_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D), -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteEvent",1237,G__G__Table_219_0_4, 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("GetPad",565,G__G__Table_219_0_5, 85, G__get_linked_tagnum(&G__G__TableLN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,G__G__Table_219_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__G__Table_219_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - width i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintBeginModel",1490,G__G__Table_219_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintEnd",787,G__G__Table_219_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintScene",1002,G__G__Table_219_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPolyMarker",1538,G__G__Table_219_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TPolyMarker3D' - 0 - marker C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPolyLine",1320,G__G__Table_219_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TPolyLine3D' - 0 - line C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPoints3D",1264,G__G__Table_219_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TPoints3DABC' - 10 - points C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PushMatrix",1045,G__G__Table_219_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopMatrix",932,G__G__Table_219_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAttNode",987,G__G__Table_219_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TNode' - 0 - node C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineAttr",1103,G__G__Table_219_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"s - 'Color_t' 0 - color i - 'Int_t' 0 - width "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPad",577,G__G__Table_219_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateNodeMatrix",1630,G__G__Table_219_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TNode' - 0 - node C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePosition",1464,G__G__Table_219_0_20, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z U 'TRotMatrix' - 0 - matrix "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateView",1022,G__G__Table_219_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,G__G__Table_219_0_22, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - min D - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Table_219_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - min D - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShift",798,G__G__Table_219_0_24, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - main_shift D - 'Double_t' 0 - extra_shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShift",810,G__G__Table_219_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - main_shift D - 'Double_t' 0 - extra_shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAngles",890,G__G__Table_219_0_26, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - main_angles D - 'Double_t' 0 - extra_angles", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAngles",902,G__G__Table_219_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - main_angles D - 'Double_t' 0 - extra_angles", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAnglesFactors",1612,G__G__Table_219_0_28, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - factors", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAnglesFactors",1624,G__G__Table_219_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - factors", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,G__G__Table_219_0_30, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScale",788,G__G__Table_219_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - scale", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("TTablePadView3D", 1379, G__G__Table_219_0_32, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D), -1, 0, 1, 1, 1, 0, "u 'TTablePadView3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTablePadView3D", 1505, G__G__Table_219_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__Table_219_0_34, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TTablePadView3D), -1, 1, 1, 1, 1, 0, "u 'TTablePadView3D' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVolumePosition(void) {
   /* TVolumePosition */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumePosition));
   G__memfunc_setup("DeleteOwnMatrix",1532,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumePosition",1569,G__G__Table_220_0_2, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 5, 1, 1, 0, 
"U 'TVolume' - 0 '0' node d - 'Double_t' 0 '0' x "
"d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
"U 'TRotMatrix' - 0 '0' matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumePosition",1569,G__G__Table_220_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 5, 1, 1, 0, 
"U 'TVolume' - 0 - node d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z "
"C - - 10 - matrixname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumePosition",1569,G__G__Table_220_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 2, 1, 1, 0, 
"U 'TVolumePosition' - 10 - oldPosition U 'TVolumePosition' - 10 - curPosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumePosition",1569,G__G__Table_220_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 1, 1, 1, 0, "u 'TVolumePosition' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Errmx2Local",1067,G__G__Table_220_0_7, 70, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"F - 'Float_t' 10 - masterError F - 'Float_t' 0 - localError", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Errmx2Local",1067,G__G__Table_220_0_8, 68, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - masterError D - 'Double_t' 0 - localError", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Errmx2Master",1196,G__G__Table_220_0_9, 70, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"F - 'Float_t' 10 - localError F - 'Float_t' 0 - masterError", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Errmx2Master",1196,G__G__Table_220_0_10, 68, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - localError D - 'Double_t' 0 - masterError", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cormx2Local",1062,G__G__Table_220_0_11, 68, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - masterCorr D - 'Double_t' 0 - localCorr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cormx2Local",1062,G__G__Table_220_0_12, 70, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"F - 'Float_t' 10 - masterCorr F - 'Float_t' 0 - localCorr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cormx2Master",1191,G__G__Table_220_0_13, 68, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - localCorr D - 'Double_t' 0 - masterCorr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cormx2Master",1191,G__G__Table_220_0_14, 70, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"F - 'Float_t' 10 - localCorr F - 'Float_t' 0 - masterCorr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Master2Local",1161,G__G__Table_220_0_15, 68, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local "
"i - 'Int_t' 0 '1' nPoints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Master2Local",1161,G__G__Table_220_0_16, 70, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 8, 
"F - 'Float_t' 10 - master F - 'Float_t' 0 - local "
"i - 'Int_t' 0 '1' nPoints", (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("DefineSet",887,G__G__Table_220_0_18, 85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 0, 1, 1, 0, "", (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 '\"3\"' depth", "*MENU*", (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("GetNode",678,G__G__Table_220_0_21, 85, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,G__G__Table_220_0_23, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrix",917,G__G__Table_220_0_25, 85, G__get_linked_tagnum(&G__G__TableLN_TRotMatrix), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Table_220_0_26, 85, G__get_linked_tagnum(&G__G__TableLN_TRotMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVisibility",1352,G__G__Table_220_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Table_220_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' indx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXYZ",555,G__G__Table_220_0_29, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetY",377,G__G__Table_220_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZ",378,G__G__Table_220_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetId",461,G__G__Table_220_0_32, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMatrixOwner",1340,G__G__Table_220_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrixOwner",1452,G__G__Table_220_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ownerShips", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Is3D",307,G__G__Table_220_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Local2Master",1161,G__G__Table_220_0_37, 68, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master "
"i - 'Int_t' 0 '1' nPoints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Local2Master",1161,G__G__Table_220_0_38, 70, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 8, 
"F - 'Float_t' 10 - local F - 'Float_t' 0 - master "
"i - 'Int_t' 0 '1' nPoints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mult",418,G__G__Table_220_0_39, 117, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 1, 1, 1, 1, 0, "u 'TVolumePosition' - 11 - position", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePosition",1464,G__G__Table_220_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Table_220_0_43, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 5, 1, 1, 0, 
"U 'TVolume' - 0 '0' node d - 'Double_t' 0 '0' x "
"d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
"U 'TRotMatrix' - 0 '0' matrix", (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("SetLineAttributes",1755,G__G__Table_220_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMatrix",929,G__G__Table_220_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRotMatrix' - 0 '0' matrix", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNode",690,G__G__Table_220_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVolume' - 0 - node", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,G__G__Table_220_0_48, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 '0' x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisibility",1364,G__G__Table_220_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' vis", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetX",388,G__G__Table_220_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY",389,G__G__Table_220_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetZ",390,G__G__Table_220_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetXYZ",567,G__G__Table_220_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 '0' xyz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetId",473,G__G__Table_220_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Table_220_0_55, 117, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 1, 1, 1, 1, 0, "u 'TVolumePosition' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_220_0_56, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVolumePosition::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_220_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumePosition::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_220_0_58, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVolumePosition::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_220_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVolumePosition::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_220_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_220_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumePosition::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_220_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolumePosition::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_220_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumePosition::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_220_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolumePosition::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVolumePosition", 1695, G__G__Table_220_0_68, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVolume(void) {
   /* TVolume */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TVolume));
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TVolumePosition' - 0 - position", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 2, 1, 2, 0, 
"U 'TVolume' - 0 - node U 'TVolumePosition' - 0 - nodePosition", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoNodePrimitive",2381,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py "
"U 'TVolumePosition' - 0 '0' position", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPositionsList",1680,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TList' - 0 '0' list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintNodePosition",1751,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - 'Option_t' 10 '\"\"' option U 'TVolumePosition' - 0 '0' postion", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TVolume",716,G__G__Table_221_0_7, 105, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolume",716,G__G__Table_221_0_8, 105, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 - shapename C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolume",716,G__G__Table_221_0_9, 105, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TShape' - 0 - shape C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolume",716,G__G__Table_221_0_10, 105, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 1, 1, 1, 0, "u 'TNode' - 1 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Table_221_0_11, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 7, 1, 1, 0, 
"U 'TVolume' - 0 - node d - 'Double_t' 0 '0' x "
"d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
"U 'TRotMatrix' - 0 '0' matrix h - 'UInt_t' 0 '0' id "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Table_221_0_12, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 7, 1, 1, 0, 
"U 'TVolume' - 0 - node d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z "
"C - - 10 - matrixname h - 'UInt_t' 0 '0' id "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapStNode2GEANTVis",1598,G__G__Table_221_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i 'TVolume::ENodeSEEN' - 0 - vis", (char*)NULL, (void*) G__func2void( (Int_t (*)(TVolume::ENodeSEEN))(&TVolume::MapStNode2GEANTVis) ), 0);
   G__memfunc_setup("MapGEANT2StNodeVis",1598,G__G__Table_221_0_14, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TVolume::MapGEANT2StNodeVis) ), 0);
   G__memfunc_setup("Add",265,G__G__Table_221_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TShape' - 0 - shape g - 'Bool_t' 0 'kFALSE' IsMaster", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTNode",1070,G__G__Table_221_0_17, 85, G__get_linked_tagnum(&G__G__TableLN_TNode), -1, 0, 1, 1, 1, 0, "U 'TVolumePosition' - 10 '0' position", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeletePosition",1448,G__G__Table_221_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVolumePosition' - 0 - position", (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 '\"3\"' depth", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawOnly",816,G__G__Table_221_0_21, 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("GetIdentity",1130,G__G__Table_221_0_23, 85, G__get_linked_tagnum(&G__G__TableLN_TRotMatrix), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TRotMatrix* (*)())(&TVolume::GetIdentity) ), 0);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,G__G__Table_221_0_25, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShape",785,G__G__Table_221_0_26, 85, G__get_linked_tagnum(&G__G__TableLN_TShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfShapes",1493,G__G__Table_221_0_27, 85, G__get_linked_tagnum(&G__G__TableLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalRange",1272,G__G__Table_221_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - min F - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVisibility",1352,G__G__Table_221_0_29, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumecLcLENodeSEEN), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfPositions",1849,G__G__Table_221_0_30, 85, G__get_linked_tagnum(&G__G__TableLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   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("ImportShapeAttributes",2195,G__G__Table_221_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMarked",784,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Is3D",307,G__G__Table_221_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Nodes",505,G__G__Table_221_0_35, 85, G__get_linked_tagnum(&G__G__TableLN_TList), -1, 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("PaintShape",1005,G__G__Table_221_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisibility",1364,G__G__Table_221_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TVolume::ENodeSEEN' - 0 'TVolume::kBothVisible' vis", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_221_0_40, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVolume::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_221_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolume::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_221_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVolume::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_221_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVolume::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_221_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_221_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolume::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_221_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolume::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_221_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolume::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_221_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolume::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TVolume", 716, G__G__Table_221_0_52, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 1, 1, 1, 0, "u 'TVolume' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVolume", 842, G__G__Table_221_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVolumeView(void) {
   /* TVolumeView */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeView));
   G__memfunc_setup("PaintShape",1005,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TVolumeView",1127,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 1, 1, 2, 0, "u 'TVolumeView' - 1 - viewNode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_3, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 2, 1, 1, 0, 
"U 'TVolumeView' - 0 - viewNode U 'TVolumePosition' - 0 '0' nodePosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_5, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 3, 1, 1, 0, 
"U 'TVolumeView' - 0 - viewNode C - 'Char_t' 10 - NodeName1 "
"C - 'Char_t' 10 '0' NodeName2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_6, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 2, 1, 1, 0, 
"U 'TVolumeView' - 0 - viewNode U 'TVolumeView' - 0 - topNode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_7, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 3, 1, 1, 0, 
"U 'TVolumeView' - 0 - viewNode U 'TVolumeView' - 10 - node1 "
"U 'TVolumeView' - 10 - node2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_8, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 5, 1, 1, 0, 
"u 'TVolume' - 1 - pattern i - 'Int_t' 0 '0' maxDepLevel "
"U 'TVolumePosition' - 10 '0' nodePosition u 'TDataSet::EDataSetPass' 'TDataSet::EDataSetPass' 0 'kMarked' iopt "
"U 'TVolumeView' - 0 '0' root", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_9, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 7, 1, 1, 0, 
"D - 'Double_t' 0 - translate D - 'Double_t' 0 - rotate "
"h - 'UInt_t' 0 - positionId U 'TVolume' - 0 - thisNode "
"C - 'Char_t' 10 - thisNodePath C - 'Char_t' 10 '0' matrixName "
"i - 'Int_t' 0 '0' matrixType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVolumeView",1127,G__G__Table_224_0_10, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeView), -1, 0, 2, 1, 1, 0, 
"U 'TVolume' - 0 - thisNode U 'TVolumePosition' - 0 - nodePosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNode",655,G__G__Table_224_0_11, 85, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 1, 1, 1, 0, "U 'TVolume' - 0 - node", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Table_224_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVolumeView' - 0 - node", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Table_224_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TShape' - 0 - shape g - 'Bool_t' 0 'kFALSE' IsMaster", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3\"' depth", "*MENU*", (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("GetPosition",1141,G__G__Table_224_0_18, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNode",678,G__G__Table_224_0_19, 85, G__get_linked_tagnum(&G__G__TableLN_TVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGlobalRange",1374,G__G__Table_224_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TVolumeView' - 10 - rootNode F - 'Float_t' 0 - min "
"F - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfShapes",1493,G__G__Table_224_0_21, 85, G__get_linked_tagnum(&G__G__TableLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLocalRange",1272,G__G__Table_224_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - min F - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShape",785,G__G__Table_224_0_24, 85, G__get_linked_tagnum(&G__G__TableLN_TShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVisibility",1352,G__G__Table_224_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMarked",784,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Is3D",307,G__G__Table_224_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Local2Master",1161,G__G__Table_224_0_28, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 2, 1, 1, 0, 
"U 'TVolumeView' - 10 - localNode U 'TVolumeView' - 10 '0' masterNode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Local2Master",1161,G__G__Table_224_0_29, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - localName C - 'Char_t' 10 '0' masterName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Local2Master",1161,G__G__Table_224_0_30, 70, -1, G__defined_typename("Float_t"), 0, 5, 1, 1, 0, 
"F - 'Float_t' 10 - local F - 'Float_t' 0 - master "
"C - 'Char_t' 10 - localName C - 'Char_t' 10 '0' masterName "
"i - 'Int_t' 0 '1' nVector", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Local2Master",1161,G__G__Table_224_0_31, 70, -1, G__defined_typename("Float_t"), 0, 5, 1, 1, 0, 
"F - 'Float_t' 10 - local F - 'Float_t' 0 - master "
"U 'TVolumeView' - 10 - localNode U 'TVolumeView' - 10 '0' masterNode "
"i - 'Int_t' 0 '1' nVector", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Nodes",505,G__G__Table_224_0_32, 85, G__get_linked_tagnum(&G__G__TableLN_TList), -1, 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("PathP",477,G__G__Table_224_0_34, 117, G__get_linked_tagnum(&G__G__TableLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineAttributes",1755,G__G__Table_224_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (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("SetVisibility",1364,G__G__Table_224_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' vis", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Table_224_0_39, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVolumeView::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_224_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumeView::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_224_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVolumeView::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_224_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVolumeView::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_224_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_224_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumeView::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_224_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolumeView::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_224_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumeView::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_224_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolumeView::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVolumeView", 1253, G__G__Table_224_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVolumeViewIter(void) {
   /* TVolumeViewIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter));
   G__memfunc_setup("GetPosition",1141,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 1, 1, 2, 9, "i - 'Int_t' 0 '0' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPositionAt",1334,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 5, 1, 2, 0, 
"U 'TVolume' - 0 - node d - 'Double_t' 0 '0' x "
"d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
"U 'TRotMatrix' - 0 '0' matrix", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPositionAt",1334,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 1, 1, 2, 0, "u 'TVolumePosition' - 1 - curPosition", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TVolumeViewIter",1531,G__G__Table_225_0_4, 105, G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter), -1, 0, 3, 1, 1, 0, 
"U 'TVolumeView' - 0 - view i - 'Int_t' 0 '1' depth "
"g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TDataSet' - 0 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDataSet' - 0 '0' l i - 'Int_t' 0 '0' depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_TDataSet), -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Table_225_0_9, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateTempMatrix",1646,G__G__Table_225_0_10, 85, G__get_linked_tagnum(&G__G__TableLN_TVolumePosition), -1, 0, 1, 1, 1, 0, "U 'TVolumePosition' - 0 - curPosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetPosition",1368,G__G__Table_225_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' level U 'TVolumePosition' - 0 '0' newPosition", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Table_225_0_12, 85, G__get_linked_tagnum(&G__G__TableLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVolumeViewIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Table_225_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumeViewIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Table_225_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVolumeViewIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Table_225_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVolumeViewIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TableLN_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__Table_225_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Table_225_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumeViewIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Table_225_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolumeViewIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Table_225_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVolumeViewIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Table_225_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVolumeViewIter::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TVolumeViewIter", 1531, G__G__Table_225_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter), -1, 0, 1, 1, 1, 0, "u 'TVolumeViewIter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVolumeViewIter", 1657, G__G__Table_225_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__Table_225_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__TableLN_TVolumeViewIter), -1, 1, 1, 1, 1, 0, "u 'TVolumeViewIter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Table() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Table() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
   G__memfunc_setup("operator<<", 996, G__G__Table__0_437, 117, G__get_linked_tagnum(&G__G__TableLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - s u 'TVolumePosition' - 11 - target", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Table() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__TableLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__TableLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TableLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__TableLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__TableLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__TableLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TableLN_tableDescriptor_st = { "tableDescriptor_st" , 115 , -1 };
G__linked_taginfo G__G__TableLN_TCL = { "TCL" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTable = { "TTable" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TIterator = { "TIterator" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TIter = { "TIter" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TListIter = { "TListIter" , 99 , -1 };
G__linked_taginfo G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__TableLN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__TableLN__x3d_sizeof_ = { "_x3d_sizeof_" , 115 , -1 };
G__linked_taginfo G__G__TableLN_TNode = { "TNode" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TShape = { "TShape" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TRotMatrix = { "TRotMatrix" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TDataSetIter = { "TDataSetIter" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TDataSet = { "TDataSet" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TDataSetcLcLEDataSetPass = { "TDataSet::EDataSetPass" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TDataSetcLcLESetBits = { "TDataSet::ESetBits" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TDataSetcLcLEBitOpt = { "TDataSet::EBitOpt" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TCut = { "TCut" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTableDescriptor = { "TTableDescriptor" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTableMap = { "TTableMap" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTablecLcLEColumnType = { "TTable::EColumnType" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TTablecLcLETableBits = { "TTable::ETableBits" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TTablecLcLiterator = { "TTable::iterator" , 99 , -1 };
G__linked_taginfo G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR = { "vector<long,allocator<long> >" , 99 , -1 };
G__linked_taginfo G__G__TableLN_vectorlElongcOallocatorlElonggRsPgRcLcLiterator = { "vector<long,allocator<long> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__TableLN_reverse_iteratorlEvectorlElongcOallocatorlElonggRsPgRcLcLiteratorgR = { "reverse_iterator<vector<long,allocator<long> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TChair = { "TChair" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TColumnView = { "TColumnView" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TKey = { "TKey" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TFileIter = { "TFileIter" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TFileSet = { "TFileSet" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TGenericTable = { "TGenericTable" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TGenericTablecLcLiterator = { "TGenericTable::iterator" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TIndexTable = { "TIndexTable" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TIndexTablecLcLiterator = { "TIndexTable::iterator" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TObjectSet = { "TObjectSet" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TObjectSetcLcLEOwnerBits = { "TObjectSet::EOwnerBits" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TPoints3DABC = { "TPoints3DABC" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TPoints3D = { "TPoints3D" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TPoints3DcLcLEOwnerBits = { "TPoints3D::EOwnerBits" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TPointsArray3D = { "TPointsArray3D" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__TableLN_EShapeTypes = { "EShapeTypes" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TPolyLineShape = { "TPolyLineShape" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TResponseTable = { "TResponseTable" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTableSorter = { "TTableSorter" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTableSortercLcL212 = { "TTableSorter::" , 117 , -1 };
G__linked_taginfo G__G__TableLN_TTablePoints = { "TTablePoints" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTable3Points = { "TTable3Points" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTable3PointscLcLEPointDirection = { "TTable3Points::EPointDirection" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TTableIter = { "TTableIter" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TPolyMarker3D = { "TPolyMarker3D" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TPolyLine3D = { "TPolyLine3D" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TTablePadView3D = { "TTablePadView3D" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TVolumePosition = { "TVolumePosition" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TVolume = { "TVolume" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TVolumecLcLENodeSEEN = { "TVolume::ENodeSEEN" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TVolumePositioncLcLEPositionBits = { "TVolumePosition::EPositionBits" , 101 , -1 };
G__linked_taginfo G__G__TableLN_TVolumeView = { "TVolumeView" , 99 , -1 };
G__linked_taginfo G__G__TableLN_TVolumeViewIter = { "TVolumeViewIter" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Table() {
  G__G__TableLN_TClass.tagnum = -1 ;
  G__G__TableLN_TBuffer.tagnum = -1 ;
  G__G__TableLN_TDirectory.tagnum = -1 ;
  G__G__TableLN_TMemberInspector.tagnum = -1 ;
  G__G__TableLN_TObject.tagnum = -1 ;
  G__G__TableLN_TNamed.tagnum = -1 ;
  G__G__TableLN_TString.tagnum = -1 ;
  G__G__TableLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TableLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__TableLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TableLN_TList.tagnum = -1 ;
  G__G__TableLN_TBrowser.tagnum = -1 ;
  G__G__TableLN_TObjArray.tagnum = -1 ;
  G__G__TableLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__TableLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TableLN_tableDescriptor_st.tagnum = -1 ;
  G__G__TableLN_TCL.tagnum = -1 ;
  G__G__TableLN_TTable.tagnum = -1 ;
  G__G__TableLN_TIterator.tagnum = -1 ;
  G__G__TableLN_TIter.tagnum = -1 ;
  G__G__TableLN_TSeqCollection.tagnum = -1 ;
  G__G__TableLN_TListIter.tagnum = -1 ;
  G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__TableLN_TAttFill.tagnum = -1 ;
  G__G__TableLN_TAttLine.tagnum = -1 ;
  G__G__TableLN_TAtt3D.tagnum = -1 ;
  G__G__TableLN__x3d_sizeof_.tagnum = -1 ;
  G__G__TableLN_TNode.tagnum = -1 ;
  G__G__TableLN_TShape.tagnum = -1 ;
  G__G__TableLN_TRotMatrix.tagnum = -1 ;
  G__G__TableLN_TDataSetIter.tagnum = -1 ;
  G__G__TableLN_TDataSet.tagnum = -1 ;
  G__G__TableLN_TDataSetcLcLEDataSetPass.tagnum = -1 ;
  G__G__TableLN_TDataSetcLcLESetBits.tagnum = -1 ;
  G__G__TableLN_TDataSetcLcLEBitOpt.tagnum = -1 ;
  G__G__TableLN_TCut.tagnum = -1 ;
  G__G__TableLN_TTableDescriptor.tagnum = -1 ;
  G__G__TableLN_TH1.tagnum = -1 ;
  G__G__TableLN_TTableMap.tagnum = -1 ;
  G__G__TableLN_TTablecLcLEColumnType.tagnum = -1 ;
  G__G__TableLN_TTablecLcLETableBits.tagnum = -1 ;
  G__G__TableLN_TTablecLcLiterator.tagnum = -1 ;
  G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR.tagnum = -1 ;
  G__G__TableLN_vectorlElongcOallocatorlElonggRsPgRcLcLiterator.tagnum = -1 ;
  G__G__TableLN_reverse_iteratorlEvectorlElongcOallocatorlElonggRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TableLN_TChair.tagnum = -1 ;
  G__G__TableLN_TColumnView.tagnum = -1 ;
  G__G__TableLN_TFile.tagnum = -1 ;
  G__G__TableLN_TKey.tagnum = -1 ;
  G__G__TableLN_TFileIter.tagnum = -1 ;
  G__G__TableLN_TFileSet.tagnum = -1 ;
  G__G__TableLN_TGenericTable.tagnum = -1 ;
  G__G__TableLN_TGenericTablecLcLiterator.tagnum = -1 ;
  G__G__TableLN_TIndexTable.tagnum = -1 ;
  G__G__TableLN_TIndexTablecLcLiterator.tagnum = -1 ;
  G__G__TableLN_TObjectSet.tagnum = -1 ;
  G__G__TableLN_TObjectSetcLcLEOwnerBits.tagnum = -1 ;
  G__G__TableLN_TPoints3DABC.tagnum = -1 ;
  G__G__TableLN_TPoints3D.tagnum = -1 ;
  G__G__TableLN_TPoints3DcLcLEOwnerBits.tagnum = -1 ;
  G__G__TableLN_TPointsArray3D.tagnum = -1 ;
  G__G__TableLN_TAttMarker.tagnum = -1 ;
  G__G__TableLN_TVirtualPad.tagnum = -1 ;
  G__G__TableLN_EShapeTypes.tagnum = -1 ;
  G__G__TableLN_TPolyLineShape.tagnum = -1 ;
  G__G__TableLN_TResponseTable.tagnum = -1 ;
  G__G__TableLN_TTableSorter.tagnum = -1 ;
  G__G__TableLN_TTableSortercLcL212.tagnum = -1 ;
  G__G__TableLN_TTablePoints.tagnum = -1 ;
  G__G__TableLN_TTable3Points.tagnum = -1 ;
  G__G__TableLN_TTable3PointscLcLEPointDirection.tagnum = -1 ;
  G__G__TableLN_TTableIter.tagnum = -1 ;
  G__G__TableLN_TPolyMarker3D.tagnum = -1 ;
  G__G__TableLN_TPolyLine3D.tagnum = -1 ;
  G__G__TableLN_TTablePadView3D.tagnum = -1 ;
  G__G__TableLN_TVolumePosition.tagnum = -1 ;
  G__G__TableLN_TVolume.tagnum = -1 ;
  G__G__TableLN_TVolumecLcLENodeSEEN.tagnum = -1 ;
  G__G__TableLN_TVolumePositioncLcLEPositionBits.tagnum = -1 ;
  G__G__TableLN_TVolumeView.tagnum = -1 ;
  G__G__TableLN_TVolumeViewIter.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Table() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__TableLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TString);
   G__get_linked_tagnum_fwd(&G__G__TableLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TableLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TableLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TList);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__TableLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TableLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_tableDescriptor_st),sizeof(tableDescriptor_st),-1,262144,(char*)NULL,G__setup_memvartableDescriptor_st,G__setup_memfunctableDescriptor_st);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TCL),sizeof(TCL),-1,1024,"C++ replacement for CERNLIB matrix / triangle matrix packages: F110 and F112",G__setup_memvarTCL,G__setup_memfuncTCL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTable),sizeof(TTable),-1,130816,"vector of the C structures",G__setup_memvarTTable,G__setup_memfuncTTable);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TIterator);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TIter);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TSeqCollection);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TListIter);
   G__get_linked_tagnum_fwd(&G__G__TableLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TAtt3D);
   G__get_linked_tagnum_fwd(&G__G__TableLN__x3d_sizeof_);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TNode);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TShape);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TRotMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TDataSetIter),sizeof(TDataSetIter),-1,62720,"class-iterator to navigate TDataSet structure",G__setup_memvarTDataSetIter,G__setup_memfuncTDataSetIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TDataSet),sizeof(TDataSet),-1,327424,"The base class to create the hierarchical data structures",G__setup_memvarTDataSet,G__setup_memfuncTDataSet);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TDataSetcLcLEDataSetPass);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TDataSetcLcLESetBits);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TDataSetcLcLEBitOpt);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TCut);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTableDescriptor),sizeof(TTableDescriptor),-1,128768,"descrpitor defining the internal layout of TTable objects",G__setup_memvarTTableDescriptor,G__setup_memfuncTTableDescriptor);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TH1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTableMap),sizeof(TTableMap),-1,96000,"\"Map\" array for TTable object",G__setup_memvarTTableMap,G__setup_memfuncTTableMap);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TTablecLcLEColumnType);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TTablecLcLETableBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTablecLcLiterator),sizeof(TTable::iterator),-1,232192,(char*)NULL,G__setup_memvarTTablecLcLiterator,G__setup_memfuncTTablecLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TableLN_vectorlElongcOallocatorlElonggRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__TableLN_reverse_iteratorlEvectorlElongcOallocatorlElonggRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TChair),sizeof(TChair),-1,325376,"A base class to provide a user custom interface to TTable class objects",G__setup_memvarTChair,G__setup_memfuncTChair);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TColumnView),sizeof(TColumnView),-1,62720,"Helper to represent one TTable column",G__setup_memvarTColumnView,G__setup_memfuncTColumnView);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TFile);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TKey);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TFileIter),sizeof(TFileIter),-1,36608,"TFile class iterator",G__setup_memvarTFileIter,G__setup_memfuncTFileIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TFileSet),sizeof(TFileSet),-1,324864,"TDataSet class to read the native file system directory structure in",G__setup_memvarTFileSet,G__setup_memfuncTFileSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TGenericTable),sizeof(TGenericTable),-1,128256,"Generic array of C-structure (a'la STL vector)",G__setup_memvarTGenericTable,G__setup_memfuncTGenericTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TGenericTablecLcLiterator),sizeof(TGenericTable::iterator),-1,232192,(char*)NULL,G__setup_memvarTGenericTablecLcLiterator,G__setup_memfuncTGenericTablecLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TIndexTable),sizeof(TIndexTable),-1,128768,"\"Index\" array for TTable object",G__setup_memvarTIndexTable,G__setup_memfuncTIndexTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TIndexTablecLcLiterator),sizeof(TIndexTable::iterator),-1,232192,(char*)NULL,G__setup_memvarTIndexTablecLcLiterator,G__setup_memfuncTIndexTablecLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TObjectSet),sizeof(TObjectSet),-1,324864,"TDataSet wrapper for TObject class objects",G__setup_memvarTObjectSet,G__setup_memfuncTObjectSet);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TObjectSetcLcLEOwnerBits);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TPoints3DABC);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TPoints3D),sizeof(TPoints3D),-1,325376,"Defines the abstract array of 3D points",G__setup_memvarTPoints3D,G__setup_memfuncTPoints3D);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TPoints3DcLcLEOwnerBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TPointsArray3D),sizeof(TPointsArray3D),-1,128768,"A 3-D PolyLine",G__setup_memvarTPointsArray3D,G__setup_memfuncTPointsArray3D);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__TableLN_EShapeTypes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TPolyLineShape),sizeof(TPolyLineShape),-1,324864,"The base class to define an abstract 3D shape of STAR \"event\" geometry",G__setup_memvarTPolyLineShape,G__setup_memfuncTPolyLineShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TResponseTable),sizeof(TResponseTable),-1,128256,"Generic Geant detector response table",G__setup_memvarTResponseTable,G__setup_memfuncTResponseTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTableSorter),sizeof(TTableSorter),-1,62720,"Is an \"observer\" class to sort the TTable objects",G__setup_memvarTTableSorter,G__setup_memfuncTTableSorter);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TTableSortercLcL212);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTablePoints),sizeof(TTablePoints),-1,324869,"Defines the TTable as an element of \"event\" geometry",G__setup_memvarTTablePoints,G__setup_memfuncTTablePoints);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTable3Points),sizeof(TTable3Points),-1,324864,"A 3-D Points",G__setup_memvarTTable3Points,G__setup_memfuncTTable3Points);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TTable3PointscLcLEPointDirection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTableIter),sizeof(TTableIter),-1,63232,"Iterator over \"sorted\" TTable objects",G__setup_memvarTTableIter,G__setup_memfuncTTableIter);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TPolyMarker3D);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TPolyLine3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TTablePadView3D),sizeof(TTablePadView3D),-1,34048,(char*)NULL,G__setup_memvarTTablePadView3D,G__setup_memfuncTTablePadView3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TVolumePosition),sizeof(TVolumePosition),-1,130816,"Description of parameters to position a 3-D geometry object",G__setup_memvarTVolumePosition,G__setup_memfuncTVolumePosition);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TVolume),sizeof(TVolume),-1,324864,"Description of parameters to position a 3-D geometry object",G__setup_memvarTVolume,G__setup_memfuncTVolume);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TVolumecLcLENodeSEEN);
   G__get_linked_tagnum_fwd(&G__G__TableLN_TVolumePositioncLcLEPositionBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TVolumeView),sizeof(TVolumeView),-1,325376,"Special kind of TDataSet",G__setup_memvarTVolumeView,G__setup_memfuncTVolumeView);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TableLN_TVolumeViewIter),sizeof(TVolumeViewIter),-1,62464,"Volume view iterator",G__setup_memvarTVolumeViewIter,G__setup_memfuncTVolumeViewIter);
}
extern "C" void G__cpp_setupG__Table(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Table()");
  G__set_cpp_environmentG__Table();
  G__cpp_setup_tagtableG__Table();

  G__cpp_setup_inheritanceG__Table();

  G__cpp_setup_typetableG__Table();

  G__cpp_setup_memvarG__Table();

  G__cpp_setup_memfuncG__Table();
  G__cpp_setup_globalG__Table();
  G__cpp_setup_funcG__Table();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Table();
  return;
}
class G__cpp_setup_initG__Table {
  public:
    G__cpp_setup_initG__Table() { G__add_setup_func("G__Table",(G__incsetup)(&G__cpp_setupG__Table)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Table() { G__remove_setup_func("G__Table"); }
};
G__cpp_setup_initG__Table G__cpp_setup_initializerG__Table;

---