G__Net.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:32:22 2011

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

#define R__DICTIONARY_FILENAME netdInetdIsrcdIG__Net
#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__Net.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void TMessage_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMessage(void *p = 0);
   static void *newArray_TMessage(Long_t size, void *p);
   static void delete_TMessage(void *p);
   static void deleteArray_TMessage(void *p);
   static void destruct_TMessage(void *p);
   static void streamer_TMessage(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSocket(void *p);
   static void deleteArray_TSocket(void *p);
   static void destruct_TSocket(void *p);
   static void streamer_TSocket(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPSocket(void *p);
   static void deleteArray_TPSocket(void *p);
   static void destruct_TPSocket(void *p);
   static void streamer_TPSocket(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TMonitor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMonitor(void *p = 0);
   static void *newArray_TMonitor(Long_t size, void *p);
   static void delete_TMonitor(void *p);
   static void deleteArray_TMonitor(void *p);
   static void destruct_TMonitor(void *p);
   static void streamer_TMonitor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TApplicationRemote_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TApplicationRemote(void *p);
   static void deleteArray_TApplicationRemote(void *p);
   static void destruct_TApplicationRemote(void *p);
   static void streamer_TApplicationRemote(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TApplicationServer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TApplicationServer(void *p);
   static void deleteArray_TApplicationServer(void *p);
   static void destruct_TApplicationServer(void *p);
   static void streamer_TApplicationServer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TFileStager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TFileStager(void *p);
   static void deleteArray_TFileStager(void *p);
   static void destruct_TFileStager(void *p);
   static void streamer_TFileStager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TServerSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TServerSocket(void *p);
   static void deleteArray_TServerSocket(void *p);
   static void destruct_TServerSocket(void *p);
   static void streamer_TServerSocket(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TFTP_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TFTP(void *p);
   static void deleteArray_TFTP(void *p);
   static void destruct_TFTP(void *p);
   static void streamer_TFTP(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGridResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGridResult(void *p = 0);
   static void *newArray_TGridResult(Long_t size, void *p);
   static void delete_TGridResult(void *p);
   static void deleteArray_TGridResult(void *p);
   static void destruct_TGridResult(void *p);

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

namespace ROOT {
   void TGridCollection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGridCollection(void *p = 0);
   static void *newArray_TGridCollection(Long_t size, void *p);
   static void delete_TGridCollection(void *p);
   static void deleteArray_TGridCollection(void *p);
   static void destruct_TGridCollection(void *p);

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

namespace ROOT {
   void TGridJobStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGridJobStatus(void *p);
   static void deleteArray_TGridJobStatus(void *p);
   static void destruct_TGridJobStatus(void *p);

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

namespace ROOT {
   void TGridJob_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGridJob(void *p);
   static void deleteArray_TGridJob(void *p);
   static void destruct_TGridJob(void *p);

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

namespace ROOT {
   void TGridJDL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGridJDL(void *p);
   static void deleteArray_TGridJDL(void *p);
   static void destruct_TGridJDL(void *p);

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

namespace ROOT {
   void TGridJobStatusList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGridJobStatusList(void *p = 0);
   static void *newArray_TGridJobStatusList(Long_t size, void *p);
   static void delete_TGridJobStatusList(void *p);
   static void deleteArray_TGridJobStatusList(void *p);
   static void destruct_TGridJobStatusList(void *p);

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

namespace ROOT {
   void TGrid_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGrid(void *p = 0);
   static void *newArray_TGrid(Long_t size, void *p);
   static void delete_TGrid(void *p);
   static void deleteArray_TGrid(void *p);
   static void destruct_TGrid(void *p);
   static void streamer_TGrid(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TNetFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TNetFile(void *p = 0);
   static void *newArray_TNetFile(Long_t size, void *p);
   static void delete_TNetFile(void *p);
   static void deleteArray_TNetFile(void *p);
   static void destruct_TNetFile(void *p);
   static void streamer_TNetFile(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNetFile*)
   {
      ::TNetFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNetFile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNetFile", ::TNetFile::Class_Version(), "include/TNetFile.h", 44,
                  typeid(::TNetFile), DefineBehavior(ptr, ptr),
                  &::TNetFile::Dictionary, isa_proxy, 0,
                  sizeof(::TNetFile) );
      instance.SetNew(&new_TNetFile);
      instance.SetNewArray(&newArray_TNetFile);
      instance.SetDelete(&delete_TNetFile);
      instance.SetDeleteArray(&deleteArray_TNetFile);
      instance.SetDestructor(&destruct_TNetFile);
      instance.SetStreamerFunc(&streamer_TNetFile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNetFile*)
   {
      return GenerateInitInstanceLocal((::TNetFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNetFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TNetSystem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TNetSystem(void *p = 0);
   static void *newArray_TNetSystem(Long_t size, void *p);
   static void delete_TNetSystem(void *p);
   static void deleteArray_TNetSystem(void *p);
   static void destruct_TNetSystem(void *p);
   static void streamer_TNetSystem(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNetSystem*)
   {
      ::TNetSystem *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNetSystem >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNetSystem", ::TNetSystem::Class_Version(), "include/TNetFile.h", 95,
                  typeid(::TNetSystem), DefineBehavior(ptr, ptr),
                  &::TNetSystem::Dictionary, isa_proxy, 0,
                  sizeof(::TNetSystem) );
      instance.SetNew(&new_TNetSystem);
      instance.SetNewArray(&newArray_TNetSystem);
      instance.SetDelete(&delete_TNetSystem);
      instance.SetDeleteArray(&deleteArray_TNetSystem);
      instance.SetDestructor(&destruct_TNetSystem);
      instance.SetStreamerFunc(&streamer_TNetSystem);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNetSystem*)
   {
      return GenerateInitInstanceLocal((::TNetSystem*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNetSystem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSecContext_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSecContext(void *p);
   static void deleteArray_TSecContext(void *p);
   static void destruct_TSecContext(void *p);
   static void streamer_TSecContext(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSecContextCleanup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSecContextCleanup(void *p);
   static void deleteArray_TSecContextCleanup(void *p);
   static void destruct_TSecContextCleanup(void *p);
   static void streamer_TSecContextCleanup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TPServerSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPServerSocket(void *p);
   static void deleteArray_TPServerSocket(void *p);
   static void destruct_TPServerSocket(void *p);
   static void streamer_TPServerSocket(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSQLColumnInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSQLColumnInfo(void *p = 0);
   static void *newArray_TSQLColumnInfo(Long_t size, void *p);
   static void delete_TSQLColumnInfo(void *p);
   static void deleteArray_TSQLColumnInfo(void *p);
   static void destruct_TSQLColumnInfo(void *p);
   static void streamer_TSQLColumnInfo(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLColumnInfo*)
   {
      ::TSQLColumnInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLColumnInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSQLColumnInfo", ::TSQLColumnInfo::Class_Version(), "include/TSQLColumnInfo.h", 19,
                  typeid(::TSQLColumnInfo), DefineBehavior(ptr, ptr),
                  &::TSQLColumnInfo::Dictionary, isa_proxy, 0,
                  sizeof(::TSQLColumnInfo) );
      instance.SetNew(&new_TSQLColumnInfo);
      instance.SetNewArray(&newArray_TSQLColumnInfo);
      instance.SetDelete(&delete_TSQLColumnInfo);
      instance.SetDeleteArray(&deleteArray_TSQLColumnInfo);
      instance.SetDestructor(&destruct_TSQLColumnInfo);
      instance.SetStreamerFunc(&streamer_TSQLColumnInfo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSQLColumnInfo*)
   {
      return GenerateInitInstanceLocal((::TSQLColumnInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLColumnInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSQLServer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSQLServer(void *p);
   static void deleteArray_TSQLServer(void *p);
   static void destruct_TSQLServer(void *p);
   static void streamer_TSQLServer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSQLMonitoringWriter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSQLMonitoringWriter(void *p);
   static void deleteArray_TSQLMonitoringWriter(void *p);
   static void destruct_TSQLMonitoringWriter(void *p);
   static void streamer_TSQLMonitoringWriter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSQLRow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSQLRow(void *p);
   static void deleteArray_TSQLRow(void *p);
   static void destruct_TSQLRow(void *p);
   static void streamer_TSQLRow(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSQLResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSQLResult(void *p);
   static void deleteArray_TSQLResult(void *p);
   static void destruct_TSQLResult(void *p);
   static void streamer_TSQLResult(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSQLStatement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSQLStatement(void *p);
   static void deleteArray_TSQLStatement(void *p);
   static void destruct_TSQLStatement(void *p);
   static void streamer_TSQLStatement(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TSQLTableInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSQLTableInfo(void *p = 0);
   static void *newArray_TSQLTableInfo(Long_t size, void *p);
   static void delete_TSQLTableInfo(void *p);
   static void deleteArray_TSQLTableInfo(void *p);
   static void destruct_TSQLTableInfo(void *p);
   static void streamer_TSQLTableInfo(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLTableInfo*)
   {
      ::TSQLTableInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLTableInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSQLTableInfo", ::TSQLTableInfo::Class_Version(), "include/TSQLTableInfo.h", 22,
                  typeid(::TSQLTableInfo), DefineBehavior(ptr, ptr),
                  &::TSQLTableInfo::Dictionary, isa_proxy, 0,
                  sizeof(::TSQLTableInfo) );
      instance.SetNew(&new_TSQLTableInfo);
      instance.SetNewArray(&newArray_TSQLTableInfo);
      instance.SetDelete(&delete_TSQLTableInfo);
      instance.SetDeleteArray(&deleteArray_TSQLTableInfo);
      instance.SetDestructor(&destruct_TSQLTableInfo);
      instance.SetStreamerFunc(&streamer_TSQLTableInfo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSQLTableInfo*)
   {
      return GenerateInitInstanceLocal((::TSQLTableInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLTableInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TWebFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TWebFile(void *p);
   static void deleteArray_TWebFile(void *p);
   static void destruct_TWebFile(void *p);
   static void streamer_TWebFile(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TWebSystem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TWebSystem(void *p = 0);
   static void *newArray_TWebSystem(Long_t size, void *p);
   static void delete_TWebSystem(void *p);
   static void deleteArray_TWebSystem(void *p);
   static void destruct_TWebSystem(void *p);
   static void streamer_TWebSystem(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TWebSystem*)
   {
      ::TWebSystem *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TWebSystem >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TWebSystem", ::TWebSystem::Class_Version(), "include/TWebFile.h", 94,
                  typeid(::TWebSystem), DefineBehavior(ptr, ptr),
                  &::TWebSystem::Dictionary, isa_proxy, 0,
                  sizeof(::TWebSystem) );
      instance.SetNew(&new_TWebSystem);
      instance.SetNewArray(&newArray_TWebSystem);
      instance.SetDelete(&delete_TWebSystem);
      instance.SetDeleteArray(&deleteArray_TWebSystem);
      instance.SetDestructor(&destruct_TWebSystem);
      instance.SetStreamerFunc(&streamer_TWebSystem);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TWebSystem*)
   {
      return GenerateInitInstanceLocal((::TWebSystem*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TWebSystem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TSocket::Streamer(R__b);
      R__b >> fSecContexts;
      R__b.CheckByteCount(R__s, R__c, TServerSocket::IsA());
   } else {
      R__c = R__b.WriteVersion(TServerSocket::IsA(), kTRUE);
      TSocket::Streamer(R__b);
      R__b << fSecContexts;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

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

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

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TSocket::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSocket.
      TClass *R__cl = ::TSocket::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAddress", &fAddress);
      R__insp.InspectMember(fAddress, "fAddress.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRecv", &fBytesRecv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesSent", &fBytesSent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalAddress", &fLocalAddress);
      R__insp.InspectMember(fLocalAddress, "fLocalAddress.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRemoteProtocol", &fRemoteProtocol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSecContext", &fSecContext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fService", &fService);
      R__insp.InspectMember(fService, "fService.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fServType", &fServType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSocket", &fSocket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTcpWindowSize", &fTcpWindowSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
      R__insp.InspectMember(fUrl, "fUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitsInfo", &fBitsInfo);
      R__insp.InspectMember(fBitsInfo, "fBitsInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUUIDs", &fUUIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastUsageMtx", &fLastUsageMtx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastUsage", &fLastUsage);
      R__insp.InspectMember(fLastUsage, "fLastUsage.");
      TNamed::ShowMembers(R__insp);
}

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

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

   TServerSocket::Streamer(R__b);
}

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

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

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

   TSocket::Streamer(R__b);
}

//______________________________________________________________________________
void TPSocket::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPSocket.
      TClass *R__cl = ::TPSocket::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSockets", &fSockets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWriteMonitor", &fWriteMonitor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadMonitor", &fReadMonitor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWriteBytesLeft", &fWriteBytesLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadBytesLeft", &fReadBytesLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWritePtr", &fWritePtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadPtr", &fReadPtr);
      TSocket::ShowMembers(R__insp);
}

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

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

   TBufferFile::Streamer(R__b);
}

//______________________________________________________________________________
void TMessage::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMessage.
      TClass *R__cl = ::TMessage::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfos", &fInfos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitsPIDs", &fBitsPIDs);
      R__insp.InspectMember(fBitsPIDs, "fBitsPIDs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWhat", &fWhat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufComp", &fBufComp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufCompCur", &fBufCompCur);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompPos", &fCompPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvolution", &fEvolution);
      TBufferFile::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMessage(void *p) {
      return  p ? new(p) ::TMessage : new ::TMessage;
   }
   static void *newArray_TMessage(Long_t nElements, void *p) {
      return p ? new(p) ::TMessage[nElements] : new ::TMessage[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMessage(void *p) {
      delete ((::TMessage*)p);
   }
   static void deleteArray_TMessage(void *p) {
      delete [] ((::TMessage*)p);
   }
   static void destruct_TMessage(void *p) {
      typedef ::TMessage current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMessage(TBuffer &buf, void *obj) {
      ((::TMessage*)obj)->::TMessage::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMessage

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

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

//______________________________________________________________________________
void TMonitor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMonitor.
      TClass *R__cl = ::TMonitor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeActive", &fDeActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReady", &fReady);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMainLoop", &fMainLoop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMonitor(void *p) {
      return  p ? new(p) ::TMonitor : new ::TMonitor;
   }
   static void *newArray_TMonitor(Long_t nElements, void *p) {
      return p ? new(p) ::TMonitor[nElements] : new ::TMonitor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMonitor(void *p) {
      delete ((::TMonitor*)p);
   }
   static void deleteArray_TMonitor(void *p) {
      delete [] ((::TMonitor*)p);
   }
   static void destruct_TMonitor(void *p) {
      typedef ::TMonitor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMonitor(TBuffer &buf, void *obj) {
      ((::TMonitor*)obj)->::TMonitor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMonitor

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TFile::Streamer(R__b);
      fEndpointUrl.Streamer(R__b);
      fUser.Streamer(R__b);
      R__b >> fSocket;
      R__b >> fProtocol;
      R__b >> fErrorCode;
      R__b >> fNetopt;
      R__b.CheckByteCount(R__s, R__c, TNetFile::IsA());
   } else {
      R__c = R__b.WriteVersion(TNetFile::IsA(), kTRUE);
      TFile::Streamer(R__b);
      fEndpointUrl.Streamer(R__b);
      fUser.Streamer(R__b);
      R__b << fSocket;
      R__b << fProtocol;
      R__b << fErrorCode;
      R__b << fNetopt;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TNetFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNetFile.
      TClass *R__cl = ::TNetFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndpointUrl", &fEndpointUrl);
      R__insp.InspectMember(fEndpointUrl, "fEndpointUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
      R__insp.InspectMember(fUser, "fUser.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCode", &fErrorCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNetopt", &fNetopt);
      TFile::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TNetFile(void *p) {
      return  p ? new(p) ::TNetFile : new ::TNetFile;
   }
   static void *newArray_TNetFile(Long_t nElements, void *p) {
      return p ? new(p) ::TNetFile[nElements] : new ::TNetFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TNetFile(void *p) {
      delete ((::TNetFile*)p);
   }
   static void deleteArray_TNetFile(void *p) {
      delete [] ((::TNetFile*)p);
   }
   static void destruct_TNetFile(void *p) {
      typedef ::TNetFile current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TNetFile(TBuffer &buf, void *obj) {
      ((::TNetFile*)obj)->::TNetFile::Streamer(buf);
   }
} // end of namespace ROOT for class ::TNetFile

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

   TSystem::Streamer(R__b);
}

//______________________________________________________________________________
void TNetSystem::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNetSystem.
      TClass *R__cl = ::TNetSystem::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirp", &fDirp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFTP", &fFTP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
      R__insp.InspectMember(fHost, "fHost.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFTPOwner", &fFTPOwner);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
      R__insp.InspectMember(fUser, "fUser.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLocal", &fIsLocal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalPrefix", &fLocalPrefix);
      R__insp.InspectMember(fLocalPrefix, "fLocalPrefix.");
      TSystem::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TNetSystem(void *p) {
      return  p ? new(p) ::TNetSystem : new ::TNetSystem;
   }
   static void *newArray_TNetSystem(Long_t nElements, void *p) {
      return p ? new(p) ::TNetSystem[nElements] : new ::TNetSystem[nElements];
   }
   // Wrapper around operator delete
   static void delete_TNetSystem(void *p) {
      delete ((::TNetSystem*)p);
   }
   static void deleteArray_TNetSystem(void *p) {
      delete [] ((::TNetSystem*)p);
   }
   static void destruct_TNetSystem(void *p) {
      typedef ::TNetSystem current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TNetSystem(TBuffer &buf, void *obj) {
      ((::TNetSystem*)obj)->::TNetSystem::Streamer(buf);
   }
} // end of namespace ROOT for class ::TNetSystem

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TFile::Streamer(R__b);
      R__b >> fSize;
      R__b >> fSocket;
      fProxy.Streamer(R__b);
      R__b >> fHasModRoot;
      R__b >> fHTTP11;
      R__b >> fNoProxy;
      fMsgReadBuffer.Streamer(R__b);
      fMsgReadBuffer10.Streamer(R__b);
      fMsgGetHead.Streamer(R__b);
      fBasicUrl.Streamer(R__b);
      fUrlOrg.Streamer(R__b);
      fBasicUrlOrg.Streamer(R__b);
      R__b.CheckByteCount(R__s, R__c, TWebFile::IsA());
   } else {
      R__c = R__b.WriteVersion(TWebFile::IsA(), kTRUE);
      TFile::Streamer(R__b);
      R__b << fSize;
      R__b << fSocket;
      fProxy.Streamer(R__b);
      R__b << fHasModRoot;
      R__b << fHTTP11;
      R__b << fNoProxy;
      fMsgReadBuffer.Streamer(R__b);
      fMsgReadBuffer10.Streamer(R__b);
      fMsgGetHead.Streamer(R__b);
      fBasicUrl.Streamer(R__b);
      fUrlOrg.Streamer(R__b);
      fBasicUrlOrg.Streamer(R__b);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TWebFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TWebFile.
      TClass *R__cl = ::TWebFile::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(), "*fSocket", &fSocket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProxy", &fProxy);
      R__insp.InspectMember(fProxy, "fProxy.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasModRoot", &fHasModRoot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHTTP11", &fHTTP11);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoProxy", &fNoProxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgReadBuffer", &fMsgReadBuffer);
      R__insp.InspectMember(fMsgReadBuffer, "fMsgReadBuffer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgReadBuffer10", &fMsgReadBuffer10);
      R__insp.InspectMember(fMsgReadBuffer10, "fMsgReadBuffer10.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgGetHead", &fMsgGetHead);
      R__insp.InspectMember(fMsgGetHead, "fMsgGetHead.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBasicUrl", &fBasicUrl);
      R__insp.InspectMember(fBasicUrl, "fBasicUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrlOrg", &fUrlOrg);
      R__insp.InspectMember(fUrlOrg, "fUrlOrg.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBasicUrlOrg", &fBasicUrlOrg);
      R__insp.InspectMember(fBasicUrlOrg, "fBasicUrlOrg.");
      TFile::ShowMembers(R__insp);
}

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

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

   TSystem::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TWebSystem(void *p) {
      return  p ? new(p) ::TWebSystem : new ::TWebSystem;
   }
   static void *newArray_TWebSystem(Long_t nElements, void *p) {
      return p ? new(p) ::TWebSystem[nElements] : new ::TWebSystem[nElements];
   }
   // Wrapper around operator delete
   static void delete_TWebSystem(void *p) {
      delete ((::TWebSystem*)p);
   }
   static void deleteArray_TWebSystem(void *p) {
      delete [] ((::TWebSystem*)p);
   }
   static void destruct_TWebSystem(void *p) {
      typedef ::TWebSystem current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TWebSystem(TBuffer &buf, void *obj) {
      ((::TWebSystem*)obj)->::TWebSystem::Streamer(buf);
   }
} // end of namespace ROOT for class ::TWebSystem

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      fHost.Streamer(R__b);
      fUser.Streamer(R__b);
      R__b >> fPort;
      R__b >> fParallel;
      R__b >> fWindowSize;
      R__b >> fProtocol;
      R__b >> fLastBlock;
      R__b >> fBlockSize;
      R__b >> fMode;
      R__b >> fRestartAt;
      fCurrentFile.Streamer(R__b);
      R__b >> fBytesWrite;
      R__b >> fBytesRead;
      R__b >> fDir;
      R__b.CheckByteCount(R__s, R__c, TFTP::IsA());
   } else {
      R__c = R__b.WriteVersion(TFTP::IsA(), kTRUE);
      TObject::Streamer(R__b);
      fHost.Streamer(R__b);
      fUser.Streamer(R__b);
      R__b << fPort;
      R__b << fParallel;
      R__b << fWindowSize;
      R__b << fProtocol;
      R__b << fLastBlock;
      R__b << fBlockSize;
      R__b << fMode;
      R__b << fRestartAt;
      fCurrentFile.Streamer(R__b);
      R__b << fBytesWrite;
      R__b << fBytesRead;
      R__b << fDir;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TFTP::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFTP.
      TClass *R__cl = ::TFTP::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
      R__insp.InspectMember(fHost, "fHost.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
      R__insp.InspectMember(fUser, "fUser.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParallel", &fParallel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWindowSize", &fWindowSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastBlock", &fLastBlock);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBlockSize", &fBlockSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRestartAt", &fRestartAt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentFile", &fCurrentFile);
      R__insp.InspectMember(fCurrentFile, "fCurrentFile.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesWrite", &fBytesWrite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
      TObject::ShowMembers(R__insp);
}

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

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TSQLServer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSQLServer.
      TClass *R__cl = ::TSQLServer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.InspectMember(fType, "fType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
      R__insp.InspectMember(fHost, "fHost.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDB", &fDB);
      R__insp.InspectMember(fDB, "fDB.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCode", &fErrorCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorMsg", &fErrorMsg);
      R__insp.InspectMember(fErrorMsg, "fErrorMsg.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorOut", &fErrorOut);
      TObject::ShowMembers(R__insp);
}

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TSQLTableInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSQLTableInfo.
      TClass *R__cl = ::TSQLTableInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColumns", &fColumns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", &fEngine);
      R__insp.InspectMember(fEngine, "fEngine.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreateTime", &fCreateTime);
      R__insp.InspectMember(fCreateTime, "fCreateTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdateTime", &fUpdateTime);
      R__insp.InspectMember(fUpdateTime, "fUpdateTime.");
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSQLTableInfo(void *p) {
      return  p ? new(p) ::TSQLTableInfo : new ::TSQLTableInfo;
   }
   static void *newArray_TSQLTableInfo(Long_t nElements, void *p) {
      return p ? new(p) ::TSQLTableInfo[nElements] : new ::TSQLTableInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSQLTableInfo(void *p) {
      delete ((::TSQLTableInfo*)p);
   }
   static void deleteArray_TSQLTableInfo(void *p) {
      delete [] ((::TSQLTableInfo*)p);
   }
   static void destruct_TSQLTableInfo(void *p) {
      typedef ::TSQLTableInfo current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSQLTableInfo(TBuffer &buf, void *obj) {
      ((::TSQLTableInfo*)obj)->::TSQLTableInfo::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSQLTableInfo

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TSQLColumnInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSQLColumnInfo.
      TClass *R__cl = ::TSQLColumnInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeName", &fTypeName);
      R__insp.InspectMember(fTypeName, "fTypeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSQLType", &fSQLType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLength", &fLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScale", &fScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigned", &fSigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullable", &fNullable);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSQLColumnInfo(void *p) {
      return  p ? new(p) ::TSQLColumnInfo : new ::TSQLColumnInfo;
   }
   static void *newArray_TSQLColumnInfo(Long_t nElements, void *p) {
      return p ? new(p) ::TSQLColumnInfo[nElements] : new ::TSQLColumnInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSQLColumnInfo(void *p) {
      delete ((::TSQLColumnInfo*)p);
   }
   static void deleteArray_TSQLColumnInfo(void *p) {
      delete [] ((::TSQLColumnInfo*)p);
   }
   static void destruct_TSQLColumnInfo(void *p) {
      typedef ::TSQLColumnInfo current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSQLColumnInfo(TBuffer &buf, void *obj) {
      ((::TSQLColumnInfo*)obj)->::TSQLColumnInfo::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSQLColumnInfo

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

   TVirtualMonitoringWriter::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGrid::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGrid.
      TClass *R__cl = ::TGrid::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridUrl", &fGridUrl);
      R__insp.InspectMember(fGridUrl, "fGridUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrid", &fGrid);
      R__insp.InspectMember(fGrid, "fGrid.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
      R__insp.InspectMember(fHost, "fHost.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
      R__insp.InspectMember(fUser, "fUser.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPw", &fPw);
      R__insp.InspectMember(fPw, "fPw.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
      R__insp.InspectMember(fOptions, "fOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGrid(void *p) {
      return  p ? new(p) ::TGrid : new ::TGrid;
   }
   static void *newArray_TGrid(Long_t nElements, void *p) {
      return p ? new(p) ::TGrid[nElements] : new ::TGrid[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGrid(void *p) {
      delete ((::TGrid*)p);
   }
   static void deleteArray_TGrid(void *p) {
      delete [] ((::TGrid*)p);
   }
   static void destruct_TGrid(void *p) {
      typedef ::TGrid current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGrid(TBuffer &buf, void *obj) {
      ((::TGrid*)obj)->::TGrid::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGrid

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGridResult(void *p) {
      return  p ? new(p) ::TGridResult : new ::TGridResult;
   }
   static void *newArray_TGridResult(Long_t nElements, void *p) {
      return p ? new(p) ::TGridResult[nElements] : new ::TGridResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGridResult(void *p) {
      delete ((::TGridResult*)p);
   }
   static void deleteArray_TGridResult(void *p) {
      delete [] ((::TGridResult*)p);
   }
   static void destruct_TGridResult(void *p) {
      typedef ::TGridResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGridResult

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGridJDL(void *p) {
      delete ((::TGridJDL*)p);
   }
   static void deleteArray_TGridJDL(void *p) {
      delete [] ((::TGridJDL*)p);
   }
   static void destruct_TGridJDL(void *p) {
      typedef ::TGridJDL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGridJDL

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGridJob(void *p) {
      delete ((::TGridJob*)p);
   }
   static void deleteArray_TGridJob(void *p) {
      delete [] ((::TGridJob*)p);
   }
   static void destruct_TGridJob(void *p) {
      typedef ::TGridJob current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGridJob

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGridJobStatus(void *p) {
      delete ((::TGridJobStatus*)p);
   }
   static void deleteArray_TGridJobStatus(void *p) {
      delete [] ((::TGridJobStatus*)p);
   }
   static void destruct_TGridJobStatus(void *p) {
      typedef ::TGridJobStatus current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGridJobStatus

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGridJobStatusList(void *p) {
      return  p ? new(p) ::TGridJobStatusList : new ::TGridJobStatusList;
   }
   static void *newArray_TGridJobStatusList(Long_t nElements, void *p) {
      return p ? new(p) ::TGridJobStatusList[nElements] : new ::TGridJobStatusList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGridJobStatusList(void *p) {
      delete ((::TGridJobStatusList*)p);
   }
   static void deleteArray_TGridJobStatusList(void *p) {
      delete [] ((::TGridJobStatusList*)p);
   }
   static void destruct_TGridJobStatusList(void *p) {
      typedef ::TGridJobStatusList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGridJobStatusList

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGridCollection(void *p) {
      return  p ? new(p) ::TGridCollection : new ::TGridCollection;
   }
   static void *newArray_TGridCollection(Long_t nElements, void *p) {
      return p ? new(p) ::TGridCollection[nElements] : new ::TGridCollection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGridCollection(void *p) {
      delete ((::TGridCollection*)p);
   }
   static void deleteArray_TGridCollection(void *p) {
      delete [] ((::TGridCollection*)p);
   }
   static void destruct_TGridCollection(void *p) {
      typedef ::TGridCollection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGridCollection

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TSecContext::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSecContext.
      TClass *R__cl = ::TSecContext::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContext", &fContext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCleanup", &fCleanup);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExpDate", &fExpDate);
      R__insp.InspectMember(fExpDate, "fExpDate.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
      R__insp.InspectMember(fHost, "fHost.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
      R__insp.InspectMember(fID, "fID.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodName", &fMethodName);
      R__insp.InspectMember(fMethodName, "fMethodName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffSet", &fOffSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToken", &fToken);
      R__insp.InspectMember(fToken, "fToken.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
      R__insp.InspectMember(fUser, "fUser.");
      TObject::ShowMembers(R__insp);
}

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TNamed::Streamer(R__b);
}

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

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

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

   TApplication::Streamer(R__b);
}

//______________________________________________________________________________
void TApplicationRemote::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TApplicationRemote.
      TClass *R__cl = ::TApplicationRemote::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
      R__insp.InspectMember(fUrl, "fUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMonitor", &fMonitor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntHandler", &fIntHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFilePath", &fLogFilePath);
      R__insp.InspectMember(fLogFilePath, "fLogFilePath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileList", &fFileList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReceivedObject", &fReceivedObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootFiles", &fRootFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkingDir", &fWorkingDir);
      TApplication::ShowMembers(R__insp);
}

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

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

   TApplication::Streamer(R__b);
}

//______________________________________________________________________________
void TApplicationServer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TApplicationServer.
      TClass *R__cl = ::TApplicationServer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
      R__insp.InspectMember(fUrl, "fUrl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsValid", &fIsValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFilePath", &fLogFilePath);
      R__insp.InspectMember(fLogFilePath, "fLogFilePath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFile", &fLogFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFileDes", &fLogFileDes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTimeLog", &fRealTimeLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessId", &fSessId);
      R__insp.InspectMember(fSessId, "fSessId.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
      R__insp.InspectMember(fWorkDir, "fWorkDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSentCanvases", &fSentCanvases);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkingDir", &fWorkingDir);
      TApplication::ShowMembers(R__insp);
}

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

/********************************************************
* net/net/src/G__Net.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__Net();

extern "C" void G__set_cpp_environmentG__Net() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("NetErrors.h");
  G__add_compiledheader("RRemoteProtocol.h");
  G__add_compiledheader("TApplicationRemote.h");
  G__add_compiledheader("TApplicationServer.h");
  G__add_compiledheader("TFileStager.h");
  G__add_compiledheader("TFTP.h");
  G__add_compiledheader("TGridCollection.h");
  G__add_compiledheader("TGrid.h");
  G__add_compiledheader("TGridJDL.h");
  G__add_compiledheader("TGridJob.h");
  G__add_compiledheader("TGridJobStatus.h");
  G__add_compiledheader("TGridJobStatusList.h");
  G__add_compiledheader("TGridResult.h");
  G__add_compiledheader("TMessage.h");
  G__add_compiledheader("TMonitor.h");
  G__add_compiledheader("TNetFile.h");
  G__add_compiledheader("TPServerSocket.h");
  G__add_compiledheader("TPSocket.h");
  G__add_compiledheader("TSecContext.h");
  G__add_compiledheader("TServerSocket.h");
  G__add_compiledheader("TSocket.h");
  G__add_compiledheader("TSQLColumnInfo.h");
  G__add_compiledheader("TSQLMonitoring.h");
  G__add_compiledheader("TSQLResult.h");
  G__add_compiledheader("TSQLRow.h");
  G__add_compiledheader("TSQLServer.h");
  G__add_compiledheader("TSQLStatement.h");
  G__add_compiledheader("TSQLTableInfo.h");
  G__add_compiledheader("TWebFile.h");
  G__cpp_reset_tagtableG__Net();
}
#include <new>
extern "C" int G__cpp_dllrevG__Net() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

static int G__G__Net_152_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TInetAddress* pobj;
         const TInetAddress xobj = ((const TSocket*) G__getstructoffset())->GetInetAddress();
         pobj = new TInetAddress(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__Net_152_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TInetAddress* pobj;
         TInetAddress xobj = ((TSocket*) G__getstructoffset())->GetLocalInetAddress();
         pobj = new TInetAddress(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__Net_152_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetPort());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Net_152_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->GetOption((ESockOptions) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Net_152_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTimeStamp* pobj;
         TTimeStamp xobj = ((TSocket*) G__getstructoffset())->GetLastUsage();
         pobj = new TTimeStamp(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__Net_152_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSocket*) G__getstructoffset())->GetUrl());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_152_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv(libp->para[0].ref ? *(TMessage**) libp->para[0].ref : *(TMessage**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_152_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Net_152_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv((char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Net_152_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Send(*(TMessage*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Net_152_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) TSocket::GetSocketBytesSent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_152_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) TSocket::GetSocketBytesRecv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_152_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (TSocket*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Net_152_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSocket::NetError((const char*) 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__Net_152_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSocket::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Net_162_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMonitor*) G__getstructoffset())->Select((TList*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Net_162_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMonitor*) G__getstructoffset())->IsActive((TSocket*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Net_170_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TApplicationServer*) G__getstructoffset())->ReceiveFile((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Net_174_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFileStager*) G__getstructoffset())->Locate((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Stage((TCollection*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Stage((TCollection*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Net_174_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = TFileStager::GetPathName((TObject*) 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__Net_174_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFileStager::Open((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Net_180_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) TServerSocket::GetAcceptOptions());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Net_180_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TServerSocket::ShowAcceptOptions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TFTP */
static int G__G__Net_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFTP* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFTP(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TFTP(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFTP(
(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) TFTP(
(const char*) 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 TFTP((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TFTP((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 TFTP((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TFTP((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__NetLN_TFTP));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFTP*) G__getstructoffset())->SetRestartAt((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_208_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TFTP*) G__getstructoffset())->GetRestartAt());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_208_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->PutFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->PutFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_208_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TFTP*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TFTP*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Net_208_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 TFTP*) G__getstructoffset())->ListDirectory((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->ListDirectory());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Net_208_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TFTP*) G__getstructoffset())->pwd();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_208_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TFTP*) G__getstructoffset())->chmod((const char*) 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__Net_208_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFTP*) G__getstructoffset())->bye();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

static int G__G__Net_213_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGridResult*) G__getstructoffset())->SetKey((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__G__Net_215_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TGridCollection*) G__getstructoffset())->GetSize((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((TGridCollection*) G__getstructoffset())->GetSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Net_215_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGridCollection*) G__getstructoffset())->SetTag((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TMap*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Net_215_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DownscaleSelection((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DownscaleSelection());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Net_215_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetExportUrl());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Net_215_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Stage((Bool_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Stage((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Stage());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


/* TGridJob */
static int G__G__Net_217_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TGridJob*) G__getstructoffset())->GetJobID();
         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__Net_217_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGridJob*) G__getstructoffset())->GetJobStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Net_218_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TGridJDL*) G__getstructoffset())->AddQuotes((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);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_218_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TGridJDL*) G__getstructoffset())->Generate();
         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__Net_218_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGridJDL*) G__getstructoffset())->SetExecutable((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGridJDL*) G__getstructoffset())->SetExecutable((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGridJDL*) G__getstructoffset())->SetExecutable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Net_220_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGrid*) G__getstructoffset())->GetHomeDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Net_220_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((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__Net_220_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Net_220_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) ((TGrid*) G__getstructoffset())->Ps((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ps((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TNetFile */
static int G__G__Net_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNetFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNetFile(
(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) TNetFile(
(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 TNetFile(
(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) TNetFile(
(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 TNetFile(
(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) TNetFile(
(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 TNetFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TNetFile((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 TNetFile((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TNetFile((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__NetLN_TNetFile));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Net_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((TNetSystem*) G__getstructoffset())->GetDirEntry((void*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((TNetSystem*) G__getstructoffset())->GetDirEntry());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Net_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSecContext*) G__getstructoffset())->AddForCleanup((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__Net_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSecContext*) G__getstructoffset())->AsString(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Net_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime* pobj;
         const TDatime xobj = ((const TSecContext*) G__getstructoffset())->GetExpDate();
         pobj = new TDatime(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__Net_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSecContext*) G__getstructoffset())->GetHost());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TSecContextCleanup */
static int G__G__Net_252_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSecContextCleanup* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSecContextCleanup(
(Int_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) TSecContextCleanup(
(Int_t) 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__NetLN_TSecContextCleanup));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Net_272_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLColumnInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) 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 TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) 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 TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo(
(const char*) G__int(libp->para[0]), (const char*) 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 TSQLColumnInfo((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLColumnInfo((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSQLColumnInfo((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__NetLN_TSQLColumnInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

static int G__G__Net_275_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetTableInfo((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetColumns((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetColumns((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__Net_275_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->GetMaxIdentifierLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->CreateDataBase((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->DropDataBase((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->Reload());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->Shutdown());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSQLServer*) G__getstructoffset())->ServerInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSQLServer*) G__getstructoffset())->IsConnected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetDBMS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetDB());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetHost());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSQLServer*) G__getstructoffset())->GetPort());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSQLServer*) G__getstructoffset())->IsError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSQLServer*) G__getstructoffset())->GetErrorCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetErrorMsg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSQLServer*) G__getstructoffset())->EnableErrorOutput((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSQLServer*) G__getstructoffset())->EnableErrorOutput();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->StartTransaction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->Commit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->Rollback());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->PingVerify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->Ping());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLServer::Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TSQLServer::SetFloatFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TSQLServer::SetFloatFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLServer::GetFloatFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLServer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLServer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSQLServer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSQLServer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLServer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLServer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLServer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLServer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_275_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLServer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSQLServer G__TTSQLServer;
static int G__G__Net_275_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[] (TSQLServer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSQLServer*) (soff+(sizeof(TSQLServer)*i)))->~G__TTSQLServer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSQLServer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSQLServer*) (soff))->~G__TTSQLServer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Net_275_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLServer* dest = (TSQLServer*) G__getstructoffset();
   *dest = *(TSQLServer*) libp->para[0].ref;
   const TSQLServer& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSQLMonitoringWriter */
static int G__G__Net_276_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLMonitoringWriter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSQLMonitoringWriter(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TSQLMonitoringWriter(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLMonitoringWriter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLMonitoringWriter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSQLMonitoringWriter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSQLMonitoringWriter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLMonitoringWriter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLMonitoringWriter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLMonitoringWriter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLMonitoringWriter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_276_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLMonitoringWriter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSQLMonitoringWriter G__TTSQLMonitoringWriter;
static int G__G__Net_276_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSQLMonitoringWriter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSQLMonitoringWriter*) (soff+(sizeof(TSQLMonitoringWriter)*i)))->~G__TTSQLMonitoringWriter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSQLMonitoringWriter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSQLMonitoringWriter*) (soff))->~G__TTSQLMonitoringWriter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSQLRow */
static int G__G__Net_277_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSQLRow*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSQLRow*) G__getstructoffset())->Close();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TSQLRow*) G__getstructoffset())->GetFieldLength((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSQLRow*) G__getstructoffset())->GetField((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSQLRow*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLRow::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLRow::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSQLRow::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSQLRow::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLRow*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLRow::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLRow::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLRow::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_277_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLRow::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSQLRow G__TTSQLRow;
static int G__G__Net_277_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[] (TSQLRow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSQLRow*) (soff+(sizeof(TSQLRow)*i)))->~G__TTSQLRow();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSQLRow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSQLRow*) (soff))->~G__TTSQLRow();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Net_277_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLRow* dest = (TSQLRow*) G__getstructoffset();
   *dest = *(TSQLRow*) libp->para[0].ref;
   const TSQLRow& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSQLResult */
static int G__G__Net_278_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSQLResult*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSQLResult*) G__getstructoffset())->Close();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLResult*) G__getstructoffset())->GetFieldCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSQLResult*) G__getstructoffset())->GetFieldName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSQLResult*) G__getstructoffset())->GetRowCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSQLResult*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSQLResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSQLResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_278_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSQLResult G__TTSQLResult;
static int G__G__Net_278_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[] (TSQLResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSQLResult*) (soff+(sizeof(TSQLResult)*i)))->~G__TTSQLResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSQLResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSQLResult*) (soff))->~G__TTSQLResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Net_278_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLResult* dest = (TSQLResult*) G__getstructoffset();
   *dest = *(TSQLResult*) libp->para[0].ref;
   const TSQLResult& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSQLStatement */
static int G__G__Net_279_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSQLStatement*) G__getstructoffset())->GetBufferLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetNumParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->NextIteration());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetNull((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetInt((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetUInt((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetLong((Int_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetLong64((Int_t) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetULong64((Int_t) G__int(libp->para[0]), (ULong64_t) G__ULonglong(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDouble((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetString((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetString((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDate((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDate((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTime((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTime((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDatime(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDatime((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTimestamp(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTimestamp(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTimestamp((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLStatement*) G__getstructoffset())->SetTimeFormating((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetBinary((Int_t) G__int(libp->para[0]), (void*) 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, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetBinary((Int_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->Process());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetNumAffectedRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->StoreResult());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetNumFields());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSQLStatement*) G__getstructoffset())->GetFieldName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetMaxFieldSize((Int_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->NextResultRow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->IsNull((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetInt((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TSQLStatement*) G__getstructoffset())->GetUInt((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TSQLStatement*) G__getstructoffset())->GetLong((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TSQLStatement*) G__getstructoffset())->GetLong64((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) ((TSQLStatement*) G__getstructoffset())->GetULong64((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TSQLStatement*) G__getstructoffset())->GetDouble((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSQLStatement*) G__getstructoffset())->GetString((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetBinary((Int_t) G__int(libp->para[0]), libp->para[1].ref ? *(void**) libp->para[1].ref : *(void**) (void*) (&G__Mlong(libp->para[1]))
, *(Long_t*) G__Longref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetDate((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetTime((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetDatime(
(Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TDatime* pobj;
         TDatime xobj = ((TSQLStatement*) G__getstructoffset())->GetDatime((Int_t) G__int(libp->para[0]));
         pobj = new TDatime(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__Net_279_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetYear((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetMonth((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetDay((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetHour((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetMinute((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetSecond((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetTimestamp(
(Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Int_t*) G__Intref(&libp->para[6]), *(Int_t*) G__Intref(&libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TDatime* pobj;
         TDatime xobj = ((TSQLStatement*) G__getstructoffset())->GetTimestamp((Int_t) G__int(libp->para[0]));
         pobj = new TDatime(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__Net_279_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSQLStatement*) G__getstructoffset())->IsError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSQLStatement*) G__getstructoffset())->GetErrorCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLStatement*) G__getstructoffset())->GetErrorMsg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSQLStatement*) G__getstructoffset())->EnableErrorOutput((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSQLStatement*) G__getstructoffset())->EnableErrorOutput();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLStatement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLStatement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSQLStatement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSQLStatement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLStatement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLStatement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLStatement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLStatement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_279_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLStatement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSQLStatement G__TTSQLStatement;
static int G__G__Net_279_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSQLStatement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSQLStatement*) (soff+(sizeof(TSQLStatement)*i)))->~G__TTSQLStatement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSQLStatement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSQLStatement*) (soff))->~G__TTSQLStatement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Net_279_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLStatement* dest = (TSQLStatement*) G__getstructoffset();
   *dest = *(TSQLStatement*) libp->para[0].ref;
   const TSQLStatement& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSQLTableInfo */
static int G__G__Net_280_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLTableInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLTableInfo[n];
     } else {
       p = new((void*) gvp) TSQLTableInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLTableInfo;
     } else {
       p = new((void*) gvp) TSQLTableInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLTableInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TSQLTableInfo(
(const char*) G__int(libp->para[0]), (TList*) 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 TSQLTableInfo((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSQLTableInfo((const char*) G__int(libp->para[0]), (TList*) 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__NetLN_TSQLTableInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetColumns());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSQLTableInfo*) G__getstructoffset())->FindColumn((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetEngine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetCreateTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetUpdateTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSQLTableInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLTableInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSQLTableInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSQLTableInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSQLTableInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLTableInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLTableInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSQLTableInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_280_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSQLTableInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Net_280_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TSQLTableInfo* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSQLTableInfo(*(TSQLTableInfo*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSQLTableInfo G__TTSQLTableInfo;
static int G__G__Net_280_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSQLTableInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSQLTableInfo*) (soff+(sizeof(TSQLTableInfo)*i)))->~G__TTSQLTableInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSQLTableInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSQLTableInfo*) (soff))->~G__TTSQLTableInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Net_280_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSQLTableInfo* dest = (TSQLTableInfo*) G__getstructoffset();
   *dest = *(TSQLTableInfo*) libp->para[0].ref;
   const TSQLTableInfo& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TWebFile */
static int G__G__Net_283_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TWebFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWebFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TWebFile((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 TWebFile((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TWebFile((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__NetLN_TWebFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TWebFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWebFile(*((TUrl*) G__int(libp->para[0])), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TWebFile(*((TUrl*) 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 TWebFile(*((TUrl*) G__int(libp->para[0])));
     } else {
       p = new((void*) gvp) TWebFile(*((TUrl*) 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__NetLN_TWebFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TWebFile::SetProxy((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebFile::GetProxy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TWebFile::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebFile::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TWebFile::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TWebFile::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TWebFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebFile::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TWebFile::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebFile::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_283_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TWebFile::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TWebFile G__TTWebFile;
static int G__G__Net_283_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TWebFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TWebFile*) (soff+(sizeof(TWebFile)*i)))->~G__TTWebFile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TWebFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TWebFile*) (soff))->~G__TTWebFile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TWebSystem */
static int G__G__Net_284_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TWebSystem* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWebSystem[n];
     } else {
       p = new((void*) gvp) TWebSystem[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TWebSystem;
     } else {
       p = new((void*) gvp) TWebSystem;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TWebSystem));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TWebSystem::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebSystem::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TWebSystem::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TWebSystem::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TWebSystem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebSystem::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TWebSystem::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TWebSystem::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Net_284_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TWebSystem::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TWebSystem G__TTWebSystem;
static int G__G__Net_284_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TWebSystem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TWebSystem*) (soff+(sizeof(TWebSystem)*i)))->~G__TTWebSystem();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TWebSystem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TWebSystem*) (soff))->~G__TTWebSystem();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TMessage */

/* TSocket */

/* TPSocket */

/* TMonitor */

/* TApplicationRemote */

/* TApplicationServer */

/* TFileStager */

/* TServerSocket */

/* TFTP */

/* TGridResult */

/* TGridCollection */

/* TGridJobStatus */

/* TGridJob */

/* TGridJDL */

/* TGridJobStatusList */

/* TGrid */

/* TNetFile */

/* TNetSystem */

/* TSecContext */

/* TSecContextCleanup */

/* TPServerSocket */

/* TSQLColumnInfo */

/* TSQLServer */

/* TSQLMonitoringWriter */

/* TSQLRow */

/* TSQLResult */

/* TSQLStatement */

/* TSQLTableInfo */

/* TWebFile */

/* TWebSystem */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Net {
 public:
  G__Sizep2memfuncG__Net(): p(&G__Sizep2memfuncG__Net::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Net::*p)();
};

size_t G__get_sizep2memfuncG__Net()
{
  G__Sizep2memfuncG__Net 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__Net() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TMessage))) {
     TMessage *G__Lderived;
     G__Lderived=(TMessage*)0x1000;
     {
       TBufferFile *G__Lpbase=(TBufferFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage),G__get_linked_tagnum(&G__G__NetLN_TBufferFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TBuffer *G__Lpbase=(TBuffer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage),G__get_linked_tagnum(&G__G__NetLN_TBuffer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSocket))) {
     TSocket *G__Lderived;
     G__Lderived=(TSocket*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TPSocket))) {
     TPSocket *G__Lderived;
     G__Lderived=(TPSocket*)0x1000;
     {
       TSocket *G__Lpbase=(TSocket*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket),G__get_linked_tagnum(&G__G__NetLN_TSocket),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TMonitor))) {
     TMonitor *G__Lderived;
     G__Lderived=(TMonitor*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor),G__get_linked_tagnum(&G__G__NetLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote))) {
     TApplicationRemote *G__Lderived;
     G__Lderived=(TApplicationRemote*)0x1000;
     {
       TApplication *G__Lpbase=(TApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote),G__get_linked_tagnum(&G__G__NetLN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote),G__get_linked_tagnum(&G__G__NetLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer))) {
     TApplicationServer *G__Lderived;
     G__Lderived=(TApplicationServer*)0x1000;
     {
       TApplication *G__Lpbase=(TApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer),G__get_linked_tagnum(&G__G__NetLN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer),G__get_linked_tagnum(&G__G__NetLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TFileStager))) {
     TFileStager *G__Lderived;
     G__Lderived=(TFileStager*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TServerSocket))) {
     TServerSocket *G__Lderived;
     G__Lderived=(TServerSocket*)0x1000;
     {
       TSocket *G__Lpbase=(TSocket*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket),G__get_linked_tagnum(&G__G__NetLN_TSocket),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TFTP))) {
     TFTP *G__Lderived;
     G__Lderived=(TFTP*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TFTP),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridResult))) {
     TGridResult *G__Lderived;
     G__Lderived=(TGridResult*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridCollection))) {
     TGridCollection *G__Lderived;
     G__Lderived=(TGridCollection*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridCollection),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus))) {
     TGridJobStatus *G__Lderived;
     G__Lderived=(TGridJobStatus*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJob))) {
     TGridJob *G__Lderived;
     G__Lderived=(TGridJob*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJob),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJDL))) {
     TGridJDL *G__Lderived;
     G__Lderived=(TGridJDL*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJDL),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList))) {
     TGridJobStatusList *G__Lderived;
     G__Lderived=(TGridJobStatusList*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGrid))) {
     TGrid *G__Lderived;
     G__Lderived=(TGrid*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGrid),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TNetFile))) {
     TNetFile *G__Lderived;
     G__Lderived=(TNetFile*)0x1000;
     {
       TFile *G__Lpbase=(TFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDirectoryFile *G__Lpbase=(TDirectoryFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TDirectoryFile),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TNetSystem))) {
     TNetSystem *G__Lderived;
     G__Lderived=(TNetSystem*)0x1000;
     {
       TSystem *G__Lpbase=(TSystem*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem),G__get_linked_tagnum(&G__G__NetLN_TSystem),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSecContext))) {
     TSecContext *G__Lderived;
     G__Lderived=(TSecContext*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContext),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup))) {
     TSecContextCleanup *G__Lderived;
     G__Lderived=(TSecContextCleanup*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket))) {
     TPServerSocket *G__Lderived;
     G__Lderived=(TPServerSocket*)0x1000;
     {
       TServerSocket *G__Lpbase=(TServerSocket*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TServerSocket),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSocket *G__Lpbase=(TSocket*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TSocket),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo))) {
     TSQLColumnInfo *G__Lderived;
     G__Lderived=(TSQLColumnInfo*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLServer))) {
     TSQLServer *G__Lderived;
     G__Lderived=(TSQLServer*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLServer),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter))) {
     TSQLMonitoringWriter *G__Lderived;
     G__Lderived=(TSQLMonitoringWriter*)0x1000;
     {
       TVirtualMonitoringWriter *G__Lpbase=(TVirtualMonitoringWriter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter),G__get_linked_tagnum(&G__G__NetLN_TVirtualMonitoringWriter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLRow))) {
     TSQLRow *G__Lderived;
     G__Lderived=(TSQLRow*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLRow),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLResult))) {
     TSQLResult *G__Lderived;
     G__Lderived=(TSQLResult*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLResult),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement))) {
     TSQLStatement *G__Lderived;
     G__Lderived=(TSQLStatement*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo))) {
     TSQLTableInfo *G__Lderived;
     G__Lderived=(TSQLTableInfo*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TWebFile))) {
     TWebFile *G__Lderived;
     G__Lderived=(TWebFile*)0x1000;
     {
       TFile *G__Lpbase=(TFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDirectoryFile *G__Lpbase=(TDirectoryFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TDirectoryFile),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TWebSystem))) {
     TWebSystem *G__Lderived;
     G__Lderived=(TWebSystem*)0x1000;
     {
       TSystem *G__Lpbase=(TSystem*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem),G__get_linked_tagnum(&G__G__NetLN_TSystem),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Net() {

   /* Setting up typedef entry */
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("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("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_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__NetLN_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__NetLN_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__NetLN_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__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TMessage */
static void G__setup_memvarTMessage(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage));
   { TMessage *p; p=(TMessage*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fInfos=",0,"Array of TStreamerInfo used in WriteObject");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TBits),-1,-1,4,"fBitsPIDs=",0,"Array of bits to mark the TProcessIDs uids written to the message");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fWhat=",0,"Message type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-1,4,"fClass=",0,"If message is kMESS_OBJECT pointer to object's class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCompress=",0,"Compression level from 0 (not compressed) to 9 (max compression)");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fBufComp=",0,"Compressed buffer");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fBufCompCur=",0,"Current position in compressed buffer");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fCompPos=",0,"Position of fBufCur when message was compressed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEvolution=",0,"True if support for schema evolution required");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgEvolution=",0,"True if global support for schema evolution required");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSocket */
static void G__setup_memvarTSocket(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket));
   { TSocket *p; p=(TSocket*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsUnix=%lldLL",(long long)TSocket::kIsUnix).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TSocket::kRead).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TSocket::kWrite).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-2,1,G__FastAllocString(2048).Format("kSOCKD=%lldLL",(long long)TSocket::kSOCKD).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-2,1,G__FastAllocString(2048).Format("kROOTD=%lldLL",(long long)TSocket::kROOTD).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-2,1,G__FastAllocString(2048).Format("kPROOFD=%lldLL",(long long)TSocket::kPROOFD).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TInetAddress),-1,-1,2,"fAddress=",0,"remote internet address and port #");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBytesRecv=",0,"total bytes received over this socket");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBytesSent=",0,"total bytes sent using this socket");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCompress=",0,"compression level from 0 (not compressed)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TInetAddress),-1,-1,2,"fLocalAddress=",0,"local internet address and port #");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRemoteProtocol=",0,"protocol of remote daemon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSecContext),-1,-1,2,"fSecContext=",0,"after a successful Authenticate call");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fService=",0,"name of service (matches remote port #)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-1,2,"fServType=",0,"remote service type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSocket=",0,"socket descriptor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTcpWindowSize=",0,"TCP window size (default 65535);");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUrl=",0,"needs this for special authentication options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TBits),-1,-1,2,"fBitsInfo=",0,"bits array to mark TStreamerInfo classes already sent");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,2,"fUUIDs=",0,"list of TProcessIDs already sent through the socket");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TVirtualMutex),-1,-1,2,"fLastUsageMtx=",0,"Protect last usage setting / reading");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TTimeStamp),-1,-1,2,"fLastUsage=",0,"Time stamp of last usage");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-2,2,"fgBytesRecv=",0,"total bytes received by all socket objects");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-2,2,"fgBytesSent=",0,"total bytes sent by all socket objects");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgClientProtocol=",0,"client \"protocol\" version");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPSocket */
static void G__setup_memvarTPSocket(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket));
   { TPSocket *p; p=(TPSocket*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSockets=",0,"array of parallel sockets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TMonitor),-1,-1,4,"fWriteMonitor=",0,"monitor write on parallel sockets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TMonitor),-1,-1,4,"fReadMonitor=",0,"monitor read from parallel sockets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,"number of parallel sockets");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWriteBytesLeft=",0,"bytes left to write for specified socket");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fReadBytesLeft=",0,"bytes left to read for specified socket");
   G__memvar_setup((void*)0,67,2,0,-1,-1,-1,4,"fWritePtr=",0,"pointer to write buffer for specified socket");
   G__memvar_setup((void*)0,67,2,0,-1,-1,-1,4,"fReadPtr=",0,"pointer to read buffer for specified socket");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMonitor */
static void G__setup_memvarTMonitor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor));
   { TMonitor *p; p=(TMonitor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fActive=",0,"list of sockets to monitor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fDeActive=",0,"list of (temporary) disabled sockets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fReady=",0,"socket which is ready to be read or written");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMainLoop=",0,"true if monitoring sockets within the main event loop");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"flags an interrupt to Select");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TMonitorcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TMonitor::kRead).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TMonitorcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TMonitor::kWrite).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TApplicationRemote */
static void G__setup_memvarTApplicationRemote(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote));
   { TApplicationRemote *p; p=(TApplicationRemote*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt),-1,-2,1,G__FastAllocString(2048).Format("kAscii=%lldLL",(long long)TApplicationRemote::kAscii).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt),-1,-2,1,G__FastAllocString(2048).Format("kBinary=%lldLL",(long long)TApplicationRemote::kBinary).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt),-1,-2,1,G__FastAllocString(2048).Format("kForce=%lldLL",(long long)TApplicationRemote::kForce).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kCollecting=%lldLL",(long long)TApplicationRemote::kCollecting).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fName=",0,"Unique name identifying this instance");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"server protocol version number");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fUrl=",0,"server's url");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"socket connection to server");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TMonitor),-1,-1,4,"fMonitor=",0,"monitor for the input socket");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"flag interrupt state");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSignalHandler),-1,-1,4,"fIntHandler=",0,"interrupt signal handler (ctrl-c)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fLogFilePath=",0,"Full remote path to log file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_THashList),-1,-1,4,"fFileList=",0,"List of files already uploaded");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TObject),-1,-1,4,"fReceivedObject=",0,"last received object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),-1,-1,4,"fRootFiles=",0,"list of (remote) root files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TRemoteObject),-1,-1,4,"fWorkingDir=",0,"working (remote) directory");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgPortAttempts=",0,"number of attempts to find a port");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgPortLower=",0,"lower bound for ports");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgPortUpper=",0,"upper bound for ports");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TApplicationServer */
static void G__setup_memvarTApplicationServer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer));
   { TApplicationServer *p; p=(TApplicationServer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"user protocol version number");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fUrl=",0,"user's url");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"socket connection to user");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsValid=",0,"flag validity");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"flag interrupt state");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fLogFilePath=",0,"Path to log file");
   G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFile=",0,"log file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLogFileDes=",0,"log file descriptor");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRealTimeLog=",0,"TRUE if log messages should be send back in real-time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fSessId=",0,"Identifier for this session");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fWorkDir=",0,"Working dir");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fSentCanvases=",0,"List of canvases already sent");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TRemoteObject),-1,-1,4,"fWorkingDir=",0,"Working (remote) directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFileStager */
static void G__setup_memvarTFileStager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager));
   { TFileStager *p; p=(TFileStager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TServerSocket */
static void G__setup_memvarTServerSocket(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket));
   { TServerSocket *p; p=(TServerSocket*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),-1,-1,4,"fSecContexts=",0,"List of TSecContext with cleanup info");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("SrvAuth_t"),-2,4,"fgSrvAuthHook=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("SrvClup_t"),-2,4,"fgSrvAuthClupHook=",0,(char*)NULL);
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-2,4,"fgAcceptOpt=",0,"Default accept options");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TServerSocketcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDefaultBacklog=%lldLL",(long long)TServerSocket::kDefaultBacklog).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFTP */
static void G__setup_memvarTFTP(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TFTP));
   { TFTP *p; p=(TFTP*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fHost=",0,"FQDN of remote host");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fUser=",0,"remote user");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,"port to which to connect");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fParallel=",0,"number of parallel sockets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWindowSize=",0,"tcp window size used");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"rootd protocol level");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLastBlock=",0,"last block successfully transfered");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBlockSize=",0,"size of data buffer used to transfer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMode=",0,"binary or ascii file transfer mode");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fRestartAt=",0,"restart transmission at specified offset");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fCurrentFile=",0,"file currently being get or put");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"! connection to rootd");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesWrite=",0,"number of bytes sent");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesRead=",0,"number of bytes received");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDir=",0,"Indicates if a remote directory is open");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,4,"fgBytesWrite=",0,"number of bytes sent by all TFTP objects");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,4,"fgBytesRead=",0,"number of bytes received by all TFTP objects");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDfltBlockSize=%lldLL",(long long)TFTP::kDfltBlockSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDfltWindowSize=%lldLL",(long long)TFTP::kDfltWindowSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBinary=%lldLL",(long long)TFTP::kBinary).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kAscii=%lldLL",(long long)TFTP::kAscii).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGridResult */
static void G__setup_memvarTGridResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult));
   { TGridResult *p; p=(TGridResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGridCollection */
static void G__setup_memvarTGridCollection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridCollection));
   { TGridCollection *p; p=(TGridCollection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGridJobStatus */
static void G__setup_memvarTGridJobStatus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus));
   { TGridJobStatus *p; p=(TGridJobStatus*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kUNKNOWN=%lldLL",(long long)TGridJobStatus::kUNKNOWN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kWAITING=%lldLL",(long long)TGridJobStatus::kWAITING).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kRUNNING=%lldLL",(long long)TGridJobStatus::kRUNNING).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kABORTED=%lldLL",(long long)TGridJobStatus::kABORTED).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kFAIL=%lldLL",(long long)TGridJobStatus::kFAIL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kDONE=%lldLL",(long long)TGridJobStatus::kDONE).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGridJob */
static void G__setup_memvarTGridJob(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJob));
   { TGridJob *p; p=(TGridJob*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fJobID=",0,"the job's ID");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGridJDL */
static void G__setup_memvarTGridJDL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJDL));
   { TGridJDL *p; p=(TGridJDL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TMap),-1,-1,2,"fMap=",0,"stores the key, value pairs of the JDL");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TMap),-1,-1,2,"fDescriptionMap=",0,"stores the key, value pairs of the JDL");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGridJobStatusList */
static void G__setup_memvarTGridJobStatusList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList));
   { TGridJobStatusList *p; p=(TGridJobStatusList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fJobID=",0,"the job's ID");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGrid */
static void G__setup_memvarTGrid(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGrid));
   { TGrid *p; p=(TGrid*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fGridUrl=",0,"the GRID url used to create the grid connection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fGrid=",0,"type of GRID (AliEn, Globus, ...)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fHost=",0,"GRID portal to which we are connected");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUser=",0,"user name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fPw=",0,"user passwd");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fOptions=",0,"options specified");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPort=",0,"port to which we are connected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TNetFile */
static void G__setup_memvarTNetFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile));
   { TNetFile *p; p=(TNetFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,2,"fEndpointUrl=",0,"URL of realfile (after possible redirection)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUser=",0,"remote user name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,2,"fSocket=",0,"connection to rootd server");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fProtocol=",0,"rootd protocol level");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fErrorCode=",0,"error code returned by rootd (matching gRootdErrStr)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNetopt=",0,"initial network options (used for ReOpen())");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TNetSystem */
static void G__setup_memvarTNetSystem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem));
   { TNetSystem *p; p=(TNetSystem*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDir=",0,"true if a directory is open remotely");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fDirp=",0,"directory handler");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TFTP),-1,-1,4,"fFTP=",0,"Connection to rootd");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fHost=",0,"Remote host");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFTPOwner=",0,"True if owner of the FTP instance");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fUser=",0,"Remote user");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,"Remote port");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsLocal=",0,"TRUE if the path points to this host");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fLocalPrefix=",0,"if fIsLocal, prefix to be prepend locally");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSecContext */
static void G__setup_memvarTSecContext(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContext));
   { TSecContext *p; p=(TSecContext*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fContext=",0,"Krb5, Globus: ptr to specific sec context");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fCleanup=",0,"Points to list with info for remote cleanup");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TDatime),-1,-1,4,"fExpDate=",0,"Expiring date (one sec precision)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fHost=",0,"Remote host name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fID=",0,"String identifying uniquely this context");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMethod=",0,"Authentication method used");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMethodName=",0,"Authentication method name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOffSet=",0,"offset in remote host auth tab file (in bytes)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fToken=",0,"Token identifying this authentication");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fUser=",0,"Remote login username");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSecContextCleanup */
static void G__setup_memvarTSecContextCleanup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup));
   { TSecContextCleanup *p; p=(TSecContextCleanup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fServerProtocol=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fServerType=",0,"0 = sockd, 1 = rootd, 2 = proofd");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPServerSocket */
static void G__setup_memvarTPServerSocket(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket));
   { TPServerSocket *p; p=(TPServerSocket*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTcpWindowSize=",0,"size of tcp window (for window scaling)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLColumnInfo */
static void G__setup_memvarTSQLColumnInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
   { TSQLColumnInfo *p; p=(TSQLColumnInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fTypeName=",0,"! sql type name, as reported by DB. Should be as much as close to declaration of column in CREATE TABLE query");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSQLType=",0,"! datatype code (see TSQLServer::ESQLDataTypes constants), -1 if not defeined");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"! size of column in bytes, -1 if not defing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLength=",0,"! datatype length definition, for instance VARCHAR(len) or FLOAT(len), -1 if not defined");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScale=",0,"! datatype scale factor, used for instance in NUMBER(len,scale) definition. -1 if not defined");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSigned=",0,"! if datatype signed or not, 0 - kFALSE, 1 - kTRUE, -1 - unknown");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNullable=",0,"! identify if value can be NULL ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLServer */
static void G__setup_memvarTSQLServer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLServer));
   { TSQLServer *p; p=(TSQLServer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fType=",0,"type of DBMS (MySQL, Oracle, SysBase, ...)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fHost=",0,"host to which we are connected");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fDB=",0,"currently selected DB");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPort=",0,"port to which we are connected");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fErrorCode=",0,"error code of last operation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fErrorMsg=",0,"error message of last operation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fErrorOut=",0,"enable error output");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-2,2,"fgFloatFmt=",0,"!  printf argument for floats and doubles, either \"%f\" or \"%e\" or \"%10f\" and so on");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_NONE=%lldLL",(long long)TSQLServer::kSQL_NONE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_CHAR=%lldLL",(long long)TSQLServer::kSQL_CHAR).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_VARCHAR=%lldLL",(long long)TSQLServer::kSQL_VARCHAR).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_INTEGER=%lldLL",(long long)TSQLServer::kSQL_INTEGER).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_FLOAT=%lldLL",(long long)TSQLServer::kSQL_FLOAT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_DOUBLE=%lldLL",(long long)TSQLServer::kSQL_DOUBLE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_NUMERIC=%lldLL",(long long)TSQLServer::kSQL_NUMERIC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_BINARY=%lldLL",(long long)TSQLServer::kSQL_BINARY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_TIMESTAMP=%lldLL",(long long)TSQLServer::kSQL_TIMESTAMP).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLMonitoringWriter */
static void G__setup_memvarTSQLMonitoringWriter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter));
   { TSQLMonitoringWriter *p; p=(TSQLMonitoringWriter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSQLServer),-1,-1,4,"fDB=",0,"SQL database where to write");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fTable=",0,"SQL table name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLRow */
static void G__setup_memvarTSQLRow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLRow));
   { TSQLRow *p; p=(TSQLRow*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLResult */
static void G__setup_memvarTSQLResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLResult));
   { TSQLResult *p; p=(TSQLResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowCount=",0,"number of rows in result");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLStatement */
static void G__setup_memvarTSQLStatement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement));
   { TSQLStatement *p; p=(TSQLStatement*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fErrorCode=",0,"error code of last operation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fErrorMsg=",0,"error message of last operation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fErrorOut=",0,"enable error output ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSQLTableInfo */
static void G__setup_memvarTSQLTableInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
   { TSQLTableInfo *p; p=(TSQLTableInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,2,"fColumns=",0,"! list of TSQLColumnInfo objects, describing each table column");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fEngine=",0,"! SQL tables engine name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fCreateTime=",0,"! table creation time ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUpdateTime=",0,"! table update time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TWebFile */
static void G__setup_memvarTWebFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile));
   { TWebFile *p; p=(TWebFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fSize=",0,"file size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"socket for HTTP/1.1 (stays alive between calls)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fProxy=",0,"proxy URL");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHasModRoot=",0,"true if server has mod_root installed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHTTP11=",0,"true if server support HTTP/1.1");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNoProxy=",0,"don't use proxy");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMsgReadBuffer=",0,"cache ReadBuffer() msg");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMsgReadBuffer10=",0,"cache ReadBuffer10() msg");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMsgGetHead=",0,"cache GetHead() msg");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fBasicUrl=",0,"basic url without authentication and options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fUrlOrg=",0,"save original url in case of temp redirection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fBasicUrlOrg=",0,"save original url in case of temp redirection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-2,4,"fgProxy=",0,"globally set proxy URL");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TWebSystem */
static void G__setup_memvarTWebSystem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem));
   { TWebSystem *p; p=(TWebSystem*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fDirp=",0,"directory handler");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Net() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMessage(void) {
   /* TMessage */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage));
   G__memfunc_setup("TMessage",793,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TMessage), -1, 0, 1, 1, 4, 0, "u 'TMessage' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TMessage' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TestBitNumber",1320,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "h - 'UInt_t' 0 - bitnumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMessage",793,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TMessage), -1, 0, 2, 1, 2, 0, 
"Y - - 0 - buf i - 'Int_t' 0 - bufsize", "only called by T(P)Socket::Recv()", (void*) NULL, 0);
   G__memfunc_setup("SetLength",910,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", "only called by T(P)Socket::Send()", (void*) NULL, 0);
   G__memfunc_setup("TMessage",793,G__G__Net_150_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TMessage), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 'kMESS_ANY' what i - 'Int_t' 0 'TBuffer::kInitialSize' bufsiz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceWriteInfo",1414,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TVirtualStreamerInfo' - 0 - info g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Forward",725,G__G__Net_150_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Net_150_0_9, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TagStreamerInfo",1515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (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("Reset",515,G__G__Net_150_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - what", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("What",404,G__G__Net_150_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWhat",704,G__G__Net_150_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - what", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableSchemaEvolution",2141,G__G__Net_150_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsesSchemaEvolution",1974,G__G__Net_150_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCompressionLevel",1974,G__G__Net_150_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompressionLevel",1962,G__G__Net_150_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Compress",844,G__G__Net_150_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Uncompress",1071,G__G__Net_150_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompBuffer",1001,G__G__Net_150_0_21, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompLength",1009,G__G__Net_150_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteObject",1122,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteProcessID",1399,(G__InterfaceMethod) NULL,114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 0, "U 'TProcessID' - 0 - pid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableSchemaEvolutionForAll",2717,G__G__Net_150_0_25, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TMessage::EnableSchemaEvolutionForAll) ), 0);
   G__memfunc_setup("UsesSchemaEvolutionForAll",2550,G__G__Net_150_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TMessage::UsesSchemaEvolutionForAll) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_150_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMessage::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_150_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessage::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_150_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMessage::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_150_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMessage::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_150_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_150_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessage::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_150_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMessage::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_150_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessage::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_150_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMessage::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMessage", 919, G__G__Net_150_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSocket(void) {
   /* TSocket */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket));
   G__memfunc_setup("TSocket",701,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Authenticate",1247,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - user", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDescriptor",1355,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - desc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendStreamerInfos",1740,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecvStreamerInfos",1746,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendProcessIDs",1385,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecvProcessIDs",1391,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 1, 1, 1, 4, 0, "u 'TSocket' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_10, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0, 
"u 'TInetAddress' - 0 - address C - - 10 - service "
"i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_11, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0, 
"u 'TInetAddress' - 0 - address i - 'Int_t' 0 - port "
"i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_12, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0, 
"C - - 10 - host C - - 10 - service "
"i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_13, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0, 
"C - - 10 - host i - 'Int_t' 0 - port "
"i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_14, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "C - - 10 - sockpath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_15, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - descriptor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_16, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - descriptor C - - 10 - sockpath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSocket",701,G__G__Net_152_0_17, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "u 'TSocket' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,G__G__Net_152_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDescriptor",1343,G__G__Net_152_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInetAddress",1398,G__G__Net_152_0_20, 117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalInetAddress",1889,G__G__Net_152_0_21, 117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPort",709,G__G__Net_152_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetService",1009,G__G__Net_152_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetServType",1122,G__G__Net_152_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalPort",1200,G__G__Net_152_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBytesSent",1217,G__G__Net_152_0_26, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBytesRecv",1207,G__G__Net_152_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompressionLevel",1962,G__G__Net_152_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorCode",1189,G__G__Net_152_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,G__G__Net_152_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i 'ESockOptions' - 0 - opt i - 'Int_t' 1 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRemoteProtocol",1758,G__G__Net_152_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecContext",1312,G__G__Net_152_0_32, 85, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTcpWindowSize",1626,G__G__Net_152_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastUsage",1193,G__G__Net_152_0_34, 117, G__get_linked_tagnum(&G__G__NetLN_TTimeStamp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUrl",595,G__G__Net_152_0_35, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAuthenticated",1535,G__G__Net_152_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,G__G__Net_152_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,G__G__Net_152_0_38, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TMessage' - 1 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,G__G__Net_152_0_39, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 1 - status i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,G__G__Net_152_0_40, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 0 - mess i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,G__G__Net_152_0_41, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 0 - mess i - 'Int_t' 0 - max "
"i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecvRaw",698,G__G__Net_152_0_42, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"Y - - 0 - buffer i - 'Int_t' 0 - length "
"i 'ESendRecvOptions' - 0 'kDefault' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reconnect",929,G__G__Net_152_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Net_152_0_44, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'kRead' interest l - 'Long_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,G__G__Net_152_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,G__G__Net_152_0_46, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,G__G__Net_152_0_47, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - status i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,G__G__Net_152_0_48, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendObject",993,G__G__Net_152_0_49, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj i - 'Int_t' 0 'kMESS_OBJECT' kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendRaw",692,G__G__Net_152_0_50, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"Y - - 10 - buffer i - 'Int_t' 0 - length "
"i 'ESendRecvOptions' - 0 'kDefault' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCompressionLevel",1974,G__G__Net_152_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOption",933,G__G__Net_152_0_52, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i 'ESockOptions' - 0 - opt i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRemoteProtocol",1770,G__G__Net_152_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rproto", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSecContext",1324,G__G__Net_152_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSecContext' - 0 - ctx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetService",1021,G__G__Net_152_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - service", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetServType",1134,G__G__Net_152_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUrl",607,G__G__Net_152_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Touch",515,G__G__Net_152_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClientProtocol",1745,G__G__Net_152_0_59, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TSocket::GetClientProtocol) ), 0);
   G__memfunc_setup("GetSocketBytesSent",1834,G__G__Net_152_0_60, 109, -1, G__defined_typename("ULong64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ULong64_t (*)())(&TSocket::GetSocketBytesSent) ), 0);
   G__memfunc_setup("GetSocketBytesRecv",1824,G__G__Net_152_0_61, 109, -1, G__defined_typename("ULong64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ULong64_t (*)())(&TSocket::GetSocketBytesRecv) ), 0);
   G__memfunc_setup("CreateAuthSocket",1615,G__G__Net_152_0_62, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 6, 3, 1, 0, 
"C - - 10 - user C - - 10 - host "
"i - 'Int_t' 0 - port i - 'Int_t' 0 '0' size "
"i - 'Int_t' 0 '-1' tcpwindowsize U 'TSocket' - 0 '0' s", (char*)NULL, (void*) G__func2void( (TSocket* (*)(const char*, const char*, Int_t, Int_t, Int_t, TSocket*))(&TSocket::CreateAuthSocket) ), 0);
   G__memfunc_setup("CreateAuthSocket",1615,G__G__Net_152_0_63, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 4, 3, 1, 0, 
"C - - 10 - url i - 'Int_t' 0 '0' size "
"i - 'Int_t' 0 '-1' tcpwindowsize U 'TSocket' - 0 '0' s", (char*)NULL, (void*) G__func2void( (TSocket* (*)(const char*, Int_t, Int_t, TSocket*))(&TSocket::CreateAuthSocket) ), 0);
   G__memfunc_setup("NetError",817,G__G__Net_152_0_64, 121, -1, -1, 0, 2, 3, 1, 0, 
"C - - 10 - where i - 'Int_t' 0 - error", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Int_t))(&TSocket::NetError) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_152_0_65, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSocket::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_152_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSocket::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_152_0_67, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSocket::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_152_0_68, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSocket::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_152_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_152_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSocket::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_152_0_74, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSocket::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_152_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSocket::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_152_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSocket::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSocket", 827, G__G__Net_152_0_77, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPSocket(void) {
   /* TPSocket */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket));
   G__memfunc_setup("TPSocket",781,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 2, 1, 4, 0, 
"U 'TSocket' - 2 - pSockets i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPSocket",781,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 1, 1, 4, 0, "u 'TPSocket' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPSocket' - 11 - -", "idem", (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - tcpwindowsize U 'TSocket' - 0 '0' sock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TPSocket",781,G__G__Net_153_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0, 
"u 'TInetAddress' - 0 - address C - - 10 - service "
"i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPSocket",781,G__G__Net_153_0_7, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0, 
"u 'TInetAddress' - 0 - address i - 'Int_t' 0 - port "
"i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPSocket",781,G__G__Net_153_0_8, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0, 
"C - - 10 - host C - - 10 - service "
"i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPSocket",781,G__G__Net_153_0_9, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0, 
"C - - 10 - host i - 'Int_t' 0 - port "
"i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPSocket",781,G__G__Net_153_0_10, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0, 
"C - - 10 - host i - 'Int_t' 0 - port "
"i - 'Int_t' 0 - size U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDescriptor",1343,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLocalInetAddress",1889,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - status i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendRaw",692,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"Y - - 10 - buffer i - 'Int_t' 0 - length "
"i 'ESendRecvOptions' - 0 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TMessage' - 1 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 1 - status i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 0 - mess i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 0 - mess i - 'Int_t' 0 - max "
"i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecvRaw",698,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"Y - - 0 - buffer i - 'Int_t' 0 - length "
"i 'ESendRecvOptions' - 0 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorCode",1189,G__G__Net_153_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i 'ESockOptions' - 0 - opt i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i 'ESockOptions' - 0 - opt i - 'Int_t' 1 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__Net_153_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_153_0_29, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPSocket::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_153_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPSocket::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_153_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPSocket::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_153_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPSocket::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_153_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_153_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPSocket::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_153_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPSocket::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_153_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPSocket::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_153_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPSocket::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPSocket", 907, G__G__Net_153_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMonitor(void) {
   /* TMonitor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor));
   G__memfunc_setup("SetReady",801,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 0, "", "used to get gTQSender", (void*) NULL, 1);
   G__memfunc_setup("TMonitor",828,G__G__Net_162_0_3, 105, G__get_linked_tagnum(&G__G__NetLN_TMonitor), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' mainloop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMonitor",828,G__G__Net_162_0_4, 105, G__get_linked_tagnum(&G__G__NetLN_TMonitor), -1, 0, 1, 1, 1, 0, "u 'TMonitor' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Net_162_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TSocket' - 0 - sock i - 'Int_t' 0 'kRead' interest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInterest",1146,G__G__Net_162_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TSocket' - 0 - sock i - 'Int_t' 0 'kRead' interest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Net_162_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAll",903,G__G__Net_162_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Activate",817,G__G__Net_162_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateAll",1098,G__G__Net_162_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeActivate",986,G__G__Net_162_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeActivateAll",1267,G__G__Net_162_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Ready",501,G__G__Net_162_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Interrupt",973,G__G__Net_162_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetInterrupt",1488,G__G__Net_162_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Select",608,G__G__Net_162_0_16, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Select",608,G__G__Net_162_0_17, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - timeout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Select",608,G__G__Net_162_0_18, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TList' - 0 - rdready U 'TList' - 0 - wrready "
"l - 'Long_t' 0 - timeout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActive",892,G__G__Net_162_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "l - 'Long_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeActive",1061,G__G__Net_162_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfActives",1600,G__G__Net_162_0_21, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfDeActives",1769,G__G__Net_162_0_22, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__Net_162_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TSocket' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_162_0_24, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMonitor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_162_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMonitor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_162_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMonitor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_162_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMonitor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_162_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_162_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMonitor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_162_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMonitor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_162_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMonitor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_162_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMonitor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMonitor", 954, G__G__Net_162_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTApplicationRemote(void) {
   /* TApplicationRemote */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote));
   G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
"C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind "
"i - 'Int_t' 0 'kRRT_Undef' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - kind i - 'Int_t' 0 'kRRT_Undef' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BroadcastObject",1514,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"U 'TObject' - 10 - obj i - 'Int_t' 0 'kMESS_OBJECT' kind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BroadcastRaw",1213,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"Y - - 10 - buffer i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckFile",862,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"C - - 10 - file l - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Collect",710,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "l - 'Long_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectInput",1238,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecvLogFile",1074,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TApplicationRemote",1844,G__G__Net_165_0_10, 105, G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote), -1, 0, 3, 1, 1, 0, 
"C - - 10 - url i - 'Int_t' 0 '0' debug "
"C - - 10 '0' script", (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("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("ApplicationName",1525,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessLine",1127,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0, 
"C - - 10 - line g - 'Bool_t' 0 'kFALSE' - "
"I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendFile",778,G__G__Net_165_0_15, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - file i - 'Int_t' 0 'kAscii' opt "
"C - - 10 '0' rfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendObject",993,G__G__Net_165_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Interrupt",973,G__G__Net_165_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kRRI_Hard' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Net_165_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' status", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPortParam",1218,G__G__Net_165_0_21, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 '-1' lower i - 'Int_t' 0 '-1' upper "
"i - 'Int_t' 0 '-1' attempts", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Int_t))(&TApplicationRemote::SetPortParam) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_165_0_22, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TApplicationRemote::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_165_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationRemote::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_165_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TApplicationRemote::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_165_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplicationRemote::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_165_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_165_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationRemote::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_165_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationRemote::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_165_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationRemote::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_165_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationRemote::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TApplicationRemote", 1970, G__G__Net_165_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTApplicationServer(void) {
   /* TApplicationServer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer));
   G__memfunc_setup("ExecLogon",900,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendCanvases",1214,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", "Send back to client any created canvas", (void*) NULL, 0);
   G__memfunc_setup("HandleCheckFile",1450,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ErrorHandler",1224,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"i - 'Int_t' 0 - level g - 'Bool_t' 0 - abort "
"C - - 10 - location C - - 10 - msg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TApplicationServer",1855,G__G__Net_170_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TApplicationServer), -1, 0, 4, 1, 1, 0, 
"I - 'Int_t' 0 - argc C - - 2 - argv "
"E - - 0 - flog C - - 10 - logfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - argc C - - 2 - argv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProtocol",1138,G__G__Net_170_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPort",709,G__G__Net_170_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUser",703,G__G__Net_170_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHost",702,G__G__Net_170_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSocket",905,G__G__Net_170_0_12, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSocketInput",1733,G__G__Net_170_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleUrgentData",1595,G__G__Net_170_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSigPipe",1277,G__G__Net_170_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Interrupt",973,G__G__Net_170_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Net_170_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessLine",1127,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0, 
"C - - 10 - line g - 'Bool_t' 0 'kFALSE' - "
"I - 'Int_t' 0 '0' err", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Net_170_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReceiveFile",1091,G__G__Net_170_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - file g - 'Bool_t' 0 - bin "
"n - 'Long64_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' retrn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendLogFile",1068,G__G__Net_170_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '0' status i - 'Int_t' 0 '-1' start "
"i - 'Int_t' 0 '-1' end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BrowseDirectory",1575,G__G__Net_170_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dirname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BrowseFile",1010,G__G__Net_170_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - fname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BrowseKey",923,G__G__Net_170_0_25, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_170_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TApplicationServer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_170_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationServer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_170_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TApplicationServer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_170_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplicationServer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_170_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__Net_170_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationServer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_170_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationServer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_170_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationServer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_170_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationServer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TApplicationServer", 1981, G__G__Net_170_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFileStager(void) {
   /* TFileStager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager));
   G__memfunc_setup("TFileStager",1082,G__G__Net_174_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 0, 1, 1, 1, 0, "C - - 10 - stager", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStaged",888,G__G__Net_174_0_2, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 1, 1, 1, 0, "U 'TCollection' - 0 - pathlist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsStaged",788,G__G__Net_174_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Locate",600,G__G__Net_174_0_4, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - u u 'TString' - 1 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Matches",709,G__G__Net_174_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stage",500,G__G__Net_174_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - - C - 'Option_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stage",500,G__G__Net_174_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TCollection' - 0 - pathlist C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,G__G__Net_174_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPathName",1070,G__G__Net_174_0_9, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - o", (char*)NULL, (void*) G__func2void( (TString (*)(TObject*))(&TFileStager::GetPathName) ), 0);
   G__memfunc_setup("Open",402,G__G__Net_174_0_10, 85, G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 0, 1, 3, 1, 0, "C - - 10 - stager", (char*)NULL, (void*) G__func2void( (TFileStager* (*)(const char*))(&TFileStager::Open) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_174_0_11, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileStager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_174_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileStager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_174_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileStager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_174_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileStager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_174_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__Net_174_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileStager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_174_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileStager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_174_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileStager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_174_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileStager::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFileStager", 1082, G__G__Net_174_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 0, 1, 1, 1, 0, "u 'TFileStager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFileStager", 1208, G__G__Net_174_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_174_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 1, 1, 1, 1, 0, "u 'TFileStager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTServerSocket(void) {
   /* TServerSocket */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket));
   G__memfunc_setup("TServerSocket",1332,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TServerSocket",1332,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 1, 1, 4, 0, "u 'TServerSocket' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TServerSocket' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Authenticate",1247,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TSocket' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TServerSocket",1332,G__G__Net_180_0_5, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - port g - 'Bool_t' 0 'kFALSE' reuse "
"i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TServerSocket",1332,G__G__Net_180_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 4, 1, 1, 0, 
"C - - 10 - service g - 'Bool_t' 0 'kFALSE' reuse "
"i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Accept",592,G__G__Net_180_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 '0' Opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLocalInetAddress",1889,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLocalPort",1200,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TMessage' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 'kMESS_STRING' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendObject",993,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - i - 'Int_t' 0 'kMESS_OBJECT' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendRaw",692,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"Y - - 10 - - i - 'Int_t' 0 - - "
"i 'ESendRecvOptions' - 0 'kDefault' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TMessage' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecvRaw",698,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"Y - - 0 - - i - 'Int_t' 0 - - "
"i 'ESendRecvOptions' - 0 'kDefault' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAcceptOptions",1628,G__G__Net_180_0_21, 98, -1, G__defined_typename("UChar_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UChar_t (*)())(&TServerSocket::GetAcceptOptions) ), 0);
   G__memfunc_setup("SetAcceptOptions",1640,G__G__Net_180_0_22, 121, -1, -1, 0, 1, 3, 1, 0, "b - 'UChar_t' 0 - Opt", (char*)NULL, (void*) G__func2void( (void (*)(UChar_t))(&TServerSocket::SetAcceptOptions) ), 0);
   G__memfunc_setup("ShowAcceptOptions",1757,G__G__Net_180_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TServerSocket::ShowAcceptOptions) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_180_0_24, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TServerSocket::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_180_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TServerSocket::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_180_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TServerSocket::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_180_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TServerSocket::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_180_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_180_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TServerSocket::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_180_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TServerSocket::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_180_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TServerSocket::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_180_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TServerSocket::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TServerSocket", 1458, G__G__Net_180_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFTP(void) {
   /* TFTP */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TFTP));
   G__memfunc_setup("TFTP",318,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TFTP), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFTP",318,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TFTP), -1, 0, 1, 1, 4, 0, "u 'TFTP' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TFTP' - 11 - -", "idem", (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"C - - 10 - url i - 'Int_t' 0 - parallel "
"i - 'Int_t' 0 - wsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintError",1047,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"C - - 10 - where i - 'Int_t' 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 8, 
"i - 'Int_t' 1 - status i 'EMessageTypes' - 1 - kind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMode",689,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFTP",318,G__G__Net_208_0_8, 105, G__get_linked_tagnum(&G__G__NetLN_TFTP), -1, 0, 4, 1, 1, 0, 
"C - - 10 - url i - 'Int_t' 0 '1' parallel "
"i - 'Int_t' 0 'kDfltWindowSize' wsize U 'TSocket' - 0 '0' sock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBlockSize",1202,G__G__Net_208_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - blockSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlockSize",1190,G__G__Net_208_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRestartAt",1222,G__G__Net_208_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - at", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRestartAt",1210,G__G__Net_208_0_12, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMode",677,G__G__Net_208_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOpen",590,G__G__Net_208_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("PutFile",697,G__G__Net_208_0_16, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 10 - file C - - 10 '0' remoteName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFile",672,G__G__Net_208_0_17, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 10 - file C - - 10 '0' localName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AccessPathName",1376,G__G__Net_208_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - path i 'EAccessMode' - 0 'kFileExists' mode "
"g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirEntry",1105,G__G__Net_208_0_19, 67, -1, -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPathInfo",1081,G__G__Net_208_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - path u 'FileStat_t' - 1 - buf "
"g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeDirectory",1531,G__G__Net_208_0_21, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeDirectory",1331,G__G__Net_208_0_22, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - dir g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteDirectory",1544,G__G__Net_208_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ListDirectory",1361,G__G__Net_208_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' cmd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeDirectory",1335,G__G__Net_208_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenDirectory",1351,G__G__Net_208_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintDirectory",1474,G__G__Net_208_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenameFile",984,G__G__Net_208_0_28, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - file1 C - - 10 - file2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteFile",979,G__G__Net_208_0_29, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangePermission",1647,G__G__Net_208_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - file i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,G__G__Net_208_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Binary",613,G__G__Net_208_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ascii",489,G__G__Net_208_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSocket",905,G__G__Net_208_0_34, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("put",345,G__G__Net_208_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - file C - - 10 '0' remoteName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("get",320,G__G__Net_208_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - file C - - 10 '0' localName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cd",199,G__G__Net_208_0_37, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mkdir",535,G__G__Net_208_0_38, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rmdir",542,G__G__Net_208_0_39, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' cmd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("pwd",331,G__G__Net_208_0_41, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mv",227,G__G__Net_208_0_42, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - file1 C - - 10 - file2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rm",223,G__G__Net_208_0_43, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chmod",523,G__G__Net_208_0_44, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - file i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("bye",320,G__G__Net_208_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("bin",313,G__G__Net_208_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ascii",521,G__G__Net_208_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_208_0_48, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFTP::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_208_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFTP::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_208_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFTP::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_208_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFTP::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_208_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__Net_208_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFTP::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_208_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFTP::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_208_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFTP::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_208_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFTP::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFTP", 444, G__G__Net_208_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGridResult(void) {
   /* TGridResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult));
   G__memfunc_setup("TGridResult",1113,G__G__Net_213_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFileName",1057,G__G__Net_213_0_2, 67, -1, -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileNamePath",1454,G__G__Net_213_0_3, 67, -1, -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPath",685,G__G__Net_213_0_4, 67, -1, -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryList",1230,G__G__Net_213_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TEntryList), -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKey",585,G__G__Net_213_0_6, 67, -1, -1, 0, 2, 1, 1, 9, 
"h - 'UInt_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKey",597,G__G__Net_213_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - - C - - 10 - - "
"C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileInfoList",1480,G__G__Net_213_0_8, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_213_0_9, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_213_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_213_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_213_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_213_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_213_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_213_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_213_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_213_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridResult::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGridResult", 1239, G__G__Net_213_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGridCollection(void) {
   /* TGridCollection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridCollection));
   G__memfunc_setup("TGridCollection",1510,G__G__Net_215_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Net_215_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Net_215_0_3, 85, G__get_linked_tagnum(&G__G__NetLN_TMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Net_215_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TMap' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTURL",615,G__G__Net_215_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSURL",614,G__G__Net_215_0_6, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLFN",512,G__G__Net_215_0_7, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__Net_215_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnline",801,G__G__Net_215_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSelected",997,G__G__Net_215_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Status",644,G__G__Net_215_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTag",584,G__G__Net_215_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"U 'TMap' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectFile",992,G__G__Net_215_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 '-1' - "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeselectFile",1193,G__G__Net_215_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 '-1' - "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvertSelection",1566,G__G__Net_215_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DownscaleSelection",1862,G__G__Net_215_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '2' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExportXML",883,G__G__Net_215_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"C - - 10 - - g - 'Bool_t' 0 'kTRUE' - "
"g - 'Bool_t' 0 'kTRUE' - C - - 10 '\"ROOT xml\"' - "
"C - - 10 '\"Exported XML\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExportUrl",1237,G__G__Net_215_0_18, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetExportUrl",1249,G__G__Net_215_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenFile",786,G__G__Net_215_0_21, 85, G__get_linked_tagnum(&G__G__NetLN_TFile), -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileGroupList",1609,G__G__Net_215_0_22, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryList",1230,G__G__Net_215_0_23, 85, G__get_linked_tagnum(&G__G__NetLN_TEntryList), -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNofGroups",1219,G__G__Net_215_0_24, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNofGroupfiles",1635,G__G__Net_215_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OverlapCollection",1765,G__G__Net_215_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGridCollection' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Net_215_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGridCollection' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stage",500,G__G__Net_215_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Prepare",719,G__G__Net_215_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckIfOnline",1266,G__G__Net_215_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDataset",998,G__G__Net_215_0_31, 85, G__get_linked_tagnum(&G__G__NetLN_TDSet), -1, 0, 3, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGridResult",1317,G__G__Net_215_0_32, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 3, 1, 1, 0, 
"C - - 10 '\"\"' - g - 'Bool_t' 0 'kTRUE' - "
"g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LookupSUrls",1139,G__G__Net_215_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTagFilterList",1598,G__G__Net_215_0_34, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTagFilterList",1610,G__G__Net_215_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCollectionName",1709,G__G__Net_215_0_36, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInfoComment",1407,G__G__Net_215_0_37, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileCollection",1708,G__G__Net_215_0_38, 85, G__get_linked_tagnum(&G__G__NetLN_TFileCollection), -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"\"' - C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_215_0_39, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridCollection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_215_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridCollection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_215_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridCollection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_215_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridCollection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_215_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__Net_215_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridCollection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_215_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridCollection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_215_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridCollection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_215_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridCollection::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGridCollection", 1510, G__G__Net_215_0_51, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 1, 1, 1, 0, "u 'TGridCollection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGridCollection", 1636, G__G__Net_215_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_215_0_53, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 1, 1, 1, 1, 0, "u 'TGridCollection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGridJobStatus(void) {
   /* TGridJobStatus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus));
   G__memfunc_setup("GetStatus",932,G__G__Net_216_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Net_216_0_3, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJobStatus::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_216_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatus::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_216_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJobStatus::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_216_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJobStatus::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_216_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_216_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatus::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_216_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatus::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_216_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatus::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_216_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatus::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGridJobStatus", 1527, G__G__Net_216_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_216_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus), -1, 1, 1, 1, 1, 0, "u 'TGridJobStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGridJob(void) {
   /* TGridJob */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJob));
   G__memfunc_setup("GetJobID",712,G__G__Net_217_0_2, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetJobStatus",1215,G__G__Net_217_0_3, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetOutputSandbox",1664,G__G__Net_217_0_4, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - localpath C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resubmit",843,G__G__Net_217_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Cancel",582,G__G__Net_217_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Net_217_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJob::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_217_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJob::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_217_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJob::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_217_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJob::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_217_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_217_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJob::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_217_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJob::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_217_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJob::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_217_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJob::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGridJob", 883, G__G__Net_217_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_217_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGridJob), -1, 1, 1, 1, 1, 0, "u 'TGridJob' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGridJDL(void) {
   /* TGridJDL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJDL));
   G__memfunc_setup("SetValue",809,G__G__Net_218_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - key C - - 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Net_218_0_3, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDescription",1456,G__G__Net_218_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - key C - - 10 - description", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDescription",1444,G__G__Net_218_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQuotes",906,G__G__Net_218_0_6, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 1, 1, 1, 0, "C - - 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToSet",760,G__G__Net_218_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - key C - - 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToSetDescription",1916,G__G__Net_218_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - key C - - 10 - description", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Generate",811,G__G__Net_218_0_9, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetExecutable",1326,G__G__Net_218_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetArguments",1250,G__G__Net_218_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetEMail",756,G__G__Net_218_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetOutputDirectory",1906,G__G__Net_218_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPrice",799,G__G__Net_218_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 '1' price C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTTL",544,G__G__Net_218_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 '72000' ttl C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetJobTag",867,G__G__Net_218_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' jobtag C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetInputDataListFormat",2235,G__G__Net_218_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"xml-single\"' format C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetInputDataList",1618,G__G__Net_218_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"collection.xml\"' list C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSplitMode",1213,G__G__Net_218_0_20, 121, -1, -1, 0, 6, 1, 1, 0, 
"C - - 10 - value h - 'UInt_t' 0 '0' maxnumberofinputfiles "
"h - 'UInt_t' 0 '0' maxinputfilesize C - - 10 '0' d1 "
"C - - 10 '0' d2 C - - 10 '0' d3", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSplitArguments",1774,G__G__Net_218_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' splitarguments C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetValidationCommand",2038,G__G__Net_218_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToInputSandbox",1707,G__G__Net_218_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToOutputSandbox",1836,G__G__Net_218_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToInputData",1366,G__G__Net_218_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToInputDataCollection",2402,G__G__Net_218_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToRequirements",1744,G__G__Net_218_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToPackages",1259,G__G__Net_218_0_28, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 '\"AliRoot\"' name C - - 10 '\"default\"' version "
"C - - 10 '\"VO_ALICE\"' type C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddToOutputArchive",1823,G__G__Net_218_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Net_218_0_30, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJDL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_218_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJDL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_218_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJDL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_218_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJDL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_218_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__Net_218_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJDL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_218_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJDL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_218_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJDL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_218_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJDL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGridJDL", 818, G__G__Net_218_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGridJobStatusList(void) {
   /* TGridJobStatusList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList));
   G__memfunc_setup("TGridJobStatusList",1813,G__G__Net_219_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_219_0_2, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJobStatusList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_219_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatusList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_219_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJobStatusList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_219_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJobStatusList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_219_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_219_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatusList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_219_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatusList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_219_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatusList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_219_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatusList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGridJobStatusList", 1939, G__G__Net_219_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGrid(void) {
   /* TGrid */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGrid));
   G__memfunc_setup("TGrid",474,G__G__Net_220_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GridUrl",697,G__G__Net_220_0_2, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGrid",678,G__G__Net_220_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHost",702,G__G__Net_220_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUser",703,G__G__Net_220_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPw",487,G__G__Net_220_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,G__G__Net_220_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPort",709,G__G__Net_220_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsConnected",1103,G__G__Net_220_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shell",504,G__G__Net_220_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stdout",643,G__G__Net_220_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stderr",628,G__G__Net_220_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Command",703,G__G__Net_220_0_13, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 3, 1, 1, 0, 
"C - - 10 - - g - 'Bool_t' 0 'kFALSE' - "
"h - 'UInt_t' 0 '2' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Query",534,G__G__Net_220_0_14, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 4, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"C - - 10 '\"\"' - C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocateSites",1120,G__G__Net_220_0_15, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Ls",191,G__G__Net_220_0_16, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 3, 1, 1, 0, 
"C - - 10 '\"\"' - C - 'Option_t' 10 '\"\"' - "
"g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pwd",299,G__G__Net_220_0_17, 67, -1, -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHomeDirectory",1630,G__G__Net_220_0_18, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cd",167,G__G__Net_220_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 '\"\"' - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mkdir",503,G__G__Net_220_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '\"\"' - C - 'Option_t' 10 '\"\"' - "
"g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rmdir",510,G__G__Net_220_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 '\"\"' - C - 'Option_t' 10 '\"\"' - "
"g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Register",837,G__G__Net_220_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"l - 'Long_t' 0 '-1' - C - - 10 '0' - "
"C - - 10 '0' - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rm",191,G__G__Net_220_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - C - 'Option_t' 10 '\"\"' - "
"g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Submit",628,G__G__Net_220_0_24, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJob), -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetJDLGenerator",1441,G__G__Net_220_0_25, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJDL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenCollection",1438,G__G__Net_220_0_26, 85, G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 2, 1, 1, 0, 
"C - - 10 - - h - 'UInt_t' 0 '1000000' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenCollectionQuery",1972,G__G__Net_220_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 2, 1, 1, 0, 
"U 'TGridResult' - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Ps",195,G__G__Net_220_0_28, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList), -1, 0, 2, 1, 1, 0, 
"C - - 10 - - g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KillById",756,G__G__Net_220_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResubmitById",1203,G__G__Net_220_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Kill",396,G__G__Net_220_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGridJob' - 0 - gridjob", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resubmit",843,G__G__Net_220_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGridJob' - 0 - gridjob", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Connect",714,G__G__Net_220_0_33, 85, G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 0, 4, 3, 1, 0, 
"C - - 10 - grid C - - 10 '0' uid "
"C - - 10 '0' pw C - - 10 '0' options", (char*)NULL, (void*) G__func2void( (TGrid* (*)(const char*, const char*, const char*, const char*))(&TGrid::Connect) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_220_0_34, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGrid::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_220_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGrid::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_220_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGrid::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_220_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGrid::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_220_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_220_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGrid::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_220_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGrid::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_220_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGrid::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_220_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGrid::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGrid", 474, G__G__Net_220_0_46, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 0, 1, 1, 1, 0, "u 'TGrid' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGrid", 600, G__G__Net_220_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_220_0_48, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 1, 1, 1, 1, 0, "u 'TGrid' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTNetFile(void) {
   /* TNetFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile));
   G__memfunc_setup("TNetFile",763,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 1, 1, 2, 0, "u 'TNetFile' - 11 - -", "NetFile cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 1, 1, 1, 2, 0, "u 'TNetFile' - 11 - -", "NetFile cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("TNetFile",763,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 4, 1, 2, 0, 
"C - - 10 - url C - - 10 - ftitle "
"i - 'Int_t' 0 - comp g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConnectServer",1345,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"I - 'Int_t' 0 - stat I 'EMessageTypes' - 0 - kind "
"i - 'Int_t' 0 - netopt i - 'Int_t' 0 - tcpwindowsize "
"g - 'Bool_t' 0 - forceOpen g - 'Bool_t' 0 - forceRead", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"C - - 10 - url C - 'Option_t' 10 - option "
"i - 'Int_t' 0 - netopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TSocket' - 0 - s C - 'Option_t' 10 - option "
"i - 'Int_t' 0 - netopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - create", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintError",1047,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - where i - 'Int_t' 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 1 - status i 'EMessageTypes' - 1 - kind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SysOpen",721,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"C - - 10 - pathname i - 'Int_t' 0 - flags "
"h - 'UInt_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysClose",821,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - fd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysStat",731,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"i - 'Int_t' 0 - fd L - 'Long_t' 0 - id "
"N - 'Long64_t' 0 - size L - 'Long_t' 0 - flags "
"L - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TNetFile",763,G__G__Net_248_0_14, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 5, 1, 1, 0, 
"C - - 10 - url 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("TNetFile",763,G__G__Net_248_0_15, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Flush",514,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorCode",1189,G__G__Net_248_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOpen",590,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Matches",709,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReOpen",585,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffers",1097,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"C - - 0 - buf N - 'Long64_t' 0 - pos "
"I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBuffer",1125,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Seek",392,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - offset i 'TFile::ERelativeTo' - 0 'kBeg' pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEndpointUrl",1428,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TUrl), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_248_0_28, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNetFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_248_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_248_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNetFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_248_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNetFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_248_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_248_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_248_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_248_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_248_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNetFile", 889, G__G__Net_248_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTNetSystem(void) {
   /* TNetSystem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem));
   G__memfunc_setup("TNetSystem",1024,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 0, 1, 1, 4, 0, "u 'TNetSystem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 1, 1, 1, 4, 0, "u 'TNetSystem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDirPtr",885,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - url U 'TSocket' - 0 '0' sock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitRemoteEntity",1661,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNetSystem",1024,G__G__Net_249_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ftpowner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNetSystem",1024,G__G__Net_249_0_7, 105, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 0, 2, 1, 1, 0, 
"C - - 10 - url g - 'Bool_t' 0 'kTRUE' ftpowner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConsistentWith",1478,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - path Y - - 0 - dirptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeDirectory",1331,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenDirectory",1351,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeDirectory",1335,G__G__Net_249_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' dirp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirEntry",1105,G__G__Net_249_0_12, 67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 '0' dirp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPathInfo",1081,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - path u 'FileStat_t' - 1 - buf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AccessPathName",1376,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - path i 'EAccessMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unlink",625,(G__InterfaceMethod) NULL,105, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_249_0_16, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNetSystem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_249_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetSystem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_249_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNetSystem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_249_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNetSystem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_249_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_249_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetSystem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_249_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetSystem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_249_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetSystem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_249_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetSystem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNetSystem", 1150, G__G__Net_249_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSecContext(void) {
   /* TSecContext */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContext));
   G__memfunc_setup("CleanupSecContext",1736,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cleanup",712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSecContext",1108,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 1, 1, 2, 0, "u 'TSecContext' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 1, 1, 1, 2, 0, "u 'TSecContext' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSecContext",1108,G__G__Net_250_0_5, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 7, 1, 1, 0, 
"C - - 10 - url i - 'Int_t' 0 - meth "
"i - 'Int_t' 0 - offset C - - 10 - id "
"C - - 10 - token u 'TDatime' - 0 'kROOTTZERO' expdate "
"Y - - 0 '0' ctx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSecContext",1108,G__G__Net_250_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 8, 1, 1, 0, 
"C - - 10 - user C - - 10 - host "
"i - 'Int_t' 0 - meth i - 'Int_t' 0 - offset "
"C - - 10 - id C - - 10 - token "
"u 'TDatime' - 0 'kROOTTZERO' expdate Y - - 0 '0' ctx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddForCleanup",1272,G__G__Net_250_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - port i - 'Int_t' 0 - proto "
"i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Net_250_0_8, 67, -1, -1, 0, 1, 1, 1, 1, "u 'TString' - 1 - out", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeActivate",986,G__G__Net_250_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"CR\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContext",1029,G__G__Net_250_0_10, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpDate",971,G__G__Net_250_0_11, 117, G__get_linked_tagnum(&G__G__NetLN_TDatime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHost",702,G__G__Net_250_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__G__Net_250_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__Net_250_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodName",1282,G__G__Net_250_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffSet",871,G__G__Net_250_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecContextCleanup",2024,G__G__Net_250_0_17, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetToken",801,G__G__Net_250_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUser",703,G__G__Net_250_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsA",253,G__G__Net_250_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - methodname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__Net_250_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"F\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetExpDate",983,G__G__Net_250_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TDatime' - 0 - expdate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetID",441,G__G__Net_250_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOffSet",883,G__G__Net_250_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUser",715,G__G__Net_250_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - user", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_250_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSecContext::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_250_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContext::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_250_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSecContext::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_250_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSecContext::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_250_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__Net_250_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContext::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_250_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContext::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_250_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContext::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_250_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContext::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSecContext", 1234, G__G__Net_250_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSecContextCleanup(void) {
   /* TSecContextCleanup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup));
   G__memfunc_setup("TSecContextCleanup",1820,G__G__Net_252_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - port i - 'Int_t' 0 - proto "
"i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPort",709,G__G__Net_252_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProtocol",1138,G__G__Net_252_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Net_252_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_252_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSecContextCleanup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_252_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContextCleanup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_252_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSecContextCleanup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_252_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSecContextCleanup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_252_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__Net_252_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContextCleanup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_252_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContextCleanup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_252_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContextCleanup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_252_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContextCleanup::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSecContextCleanup", 1820, G__G__Net_252_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup), -1, 0, 1, 1, 1, 0, "u 'TSecContextCleanup' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSecContextCleanup", 1946, G__G__Net_252_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_252_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup), -1, 1, 1, 1, 1, 0, "u 'TSecContextCleanup' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPServerSocket(void) {
   /* TPServerSocket */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket));
   G__memfunc_setup("TPServerSocket",1412,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TPServerSocket), -1, 0, 1, 1, 4, 0, "u 'TPServerSocket' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPServerSocket' - 11 - -", "idem", (void*) NULL, 0);
   G__memfunc_setup("TPServerSocket",1412,G__G__Net_271_0_3, 105, G__get_linked_tagnum(&G__G__NetLN_TPServerSocket), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - port g - 'Bool_t' 0 'kFALSE' reuse "
"i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPServerSocket",1412,G__G__Net_271_0_4, 105, G__get_linked_tagnum(&G__G__NetLN_TPServerSocket), -1, 0, 4, 1, 1, 0, 
"C - - 10 - service g - 'Bool_t' 0 'kFALSE' reuse "
"i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Accept",592,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 'kSrvNoAuth' Opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_271_0_6, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPServerSocket::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_271_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPServerSocket::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_271_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPServerSocket::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_271_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPServerSocket::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_271_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__Net_271_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPServerSocket::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_271_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPServerSocket::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_271_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPServerSocket::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_271_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPServerSocket::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPServerSocket", 1538, G__G__Net_271_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLColumnInfo(void) {
   /* TSQLColumnInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
   G__memfunc_setup("TSQLColumnInfo",1342,G__G__Net_272_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSQLColumnInfo",1342,G__G__Net_272_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 8, 1, 1, 0, 
"C - - 10 - columnname C - - 10 '\"unknown\"' sqltypename "
"g - 'Bool_t' 0 'kFALSE' nullable i - 'Int_t' 0 '-1' sqltype "
"i - 'Int_t' 0 '-1' size i - 'Int_t' 0 '-1' length "
"i - 'Int_t' 0 '-1' scale i - 'Int_t' 0 '-1' sign", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,G__G__Net_272_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNullable",1003,G__G__Net_272_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSQLType",946,G__G__Net_272_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Net_272_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLength",898,G__G__Net_272_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__Net_272_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSigned",890,G__G__Net_272_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSigned",790,G__G__Net_272_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsUnsigned",1017,G__G__Net_272_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Net_272_0_13, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLColumnInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_272_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLColumnInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_272_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLColumnInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_272_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLColumnInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_272_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_272_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLColumnInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_272_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLColumnInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_272_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLColumnInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_272_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLColumnInfo::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSQLColumnInfo", 1342, G__G__Net_272_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 1, 1, 1, 0, "u 'TSQLColumnInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSQLColumnInfo", 1468, G__G__Net_272_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_272_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 1, 1, 1, 1, 0, "u 'TSQLColumnInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLServer(void) {
   /* TSQLServer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLServer));
   G__memfunc_setup("ClearError",1009,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - code C - - 10 - msg "
"C - - 10 '0' method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,G__G__Net_275_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Query",534,G__G__Net_275_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 1, 1, 1, 0, "C - - 10 - sql", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Exec",389,G__G__Net_275_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - sql", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Statement",949,G__G__Net_275_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLStatement), -1, 0, 2, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 '100' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasStatement",1233,G__G__Net_275_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectDataBase",1365,G__G__Net_275_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dbname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetDataBases",1160,G__G__Net_275_0_10, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 1, 1, 1, 0, "C - - 10 '0' wild", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTables",891,G__G__Net_275_0_11, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 2, 1, 1, 0, 
"C - - 10 - dbname C - - 10 '0' wild", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTablesList",1303,G__G__Net_275_0_12, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 1, 1, 1, 0, "C - - 10 '0' wild", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasTable",772,G__G__Net_275_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - tablename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableInfo",1172,G__G__Net_275_0_14, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - tablename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColumns",1025,G__G__Net_275_0_15, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 3, 1, 1, 0, 
"C - - 10 - dbname C - - 10 - table "
"C - - 10 '0' wild", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMaxIdentifierLength",2219,G__G__Net_275_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateDataBase",1353,G__G__Net_275_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dbname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DropDataBase",1162,G__G__Net_275_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dbname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Reload",599,G__G__Net_275_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Shutdown",860,G__G__Net_275_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ServerInfo",1027,G__G__Net_275_0_21, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsConnected",1103,G__G__Net_275_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDBMS",582,G__G__Net_275_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDB",422,G__G__Net_275_0_24, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHost",702,G__G__Net_275_0_25, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPort",709,G__G__Net_275_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsError",710,G__G__Net_275_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorCode",1189,G__G__Net_275_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorMsg",1105,G__G__Net_275_0_29, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableErrorOutput",1762,G__G__Net_275_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartTransaction",1684,G__G__Net_275_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Commit",617,G__G__Net_275_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rollback",810,G__G__Net_275_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PingVerify",1027,G__G__Net_275_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Ping",398,G__G__Net_275_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Connect",714,G__G__Net_275_0_36, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLServer), -1, 0, 3, 3, 1, 0, 
"C - - 10 - db C - - 10 - uid "
"C - - 10 - pw", (char*)NULL, (void*) G__func2void( (TSQLServer* (*)(const char*, const char*, const char*))(&TSQLServer::Connect) ), 0);
   G__memfunc_setup("SetFloatFormat",1419,G__G__Net_275_0_37, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 '\"%e\"' fmt", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TSQLServer::SetFloatFormat) ), 0);
   G__memfunc_setup("GetFloatFormat",1407,G__G__Net_275_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::GetFloatFormat) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_275_0_39, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLServer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_275_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_275_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLServer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_275_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLServer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_275_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__Net_275_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_275_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLServer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_275_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_275_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLServer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSQLServer", 1081, G__G__Net_275_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_275_0_52, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLServer), -1, 1, 1, 1, 1, 0, "u 'TSQLServer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLMonitoringWriter(void) {
   /* TSQLMonitoringWriter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter));
   G__memfunc_setup("TSQLMonitoringWriter",2023,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter), -1, 0, 1, 1, 4, 0, "u 'TSQLMonitoringWriter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter), -1, 1, 1, 1, 4, 0, "u 'TSQLMonitoringWriter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TSQLMonitoringWriter",2023,G__G__Net_276_0_3, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter), -1, 0, 4, 1, 1, 0, 
"C - - 10 - serv C - - 10 - user "
"C - - 10 - pass C - - 10 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendParameters",1438,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TList' - 0 - values C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_276_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLMonitoringWriter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_276_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLMonitoringWriter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_276_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLMonitoringWriter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_276_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLMonitoringWriter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_276_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__Net_276_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLMonitoringWriter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_276_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLMonitoringWriter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_276_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLMonitoringWriter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_276_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLMonitoringWriter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSQLMonitoringWriter", 2149, G__G__Net_276_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLRow(void) {
   /* TSQLRow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLRow));
   G__memfunc_setup("Close",502,G__G__Net_277_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFieldLength",1382,G__G__Net_277_0_3, 107, -1, G__defined_typename("ULong_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetField",772,G__G__Net_277_0_4, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator[]",1060,G__G__Net_277_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_277_0_6, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLRow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_277_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLRow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_277_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLRow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_277_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLRow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_277_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__Net_277_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLRow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_277_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLRow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_277_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLRow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_277_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLRow::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSQLRow", 762, G__G__Net_277_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_277_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLRow), -1, 1, 1, 1, 1, 0, "u 'TSQLRow' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLResult(void) {
   /* TSQLResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLResult));
   G__memfunc_setup("Close",502,G__G__Net_278_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFieldCount",1293,G__G__Net_278_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFieldName",1157,G__G__Net_278_0_4, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowCount",1121,G__G__Net_278_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Net_278_0_6, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLRow), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Net_278_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_278_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_278_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_278_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_278_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_278_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_278_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_278_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_278_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLResult::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSQLResult", 1089, G__G__Net_278_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_278_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 1, 1, 1, 1, 0, "u 'TSQLResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLStatement(void) {
   /* TSQLStatement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement));
   G__memfunc_setup("ClearError",1009,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - code C - - 10 - msg "
"C - - 10 '0' method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufferLength",1500,G__G__Net_279_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNumParameters",1636,G__G__Net_279_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("NextIteration",1358,G__G__Net_279_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetNull",711,G__G__Net_279_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInt",599,G__G__Net_279_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUInt",684,G__G__Net_279_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLong",700,G__G__Net_279_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLong64",806,G__G__Net_279_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetULong64",891,G__G__Net_279_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - m - 'ULong64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDouble",903,G__G__Net_279_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetString",931,G__G__Net_279_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - C - - 10 - - "
"i - 'Int_t' 0 '256' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDate",682,G__G__Net_279_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDate",682,G__G__Net_279_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__G__Net_279_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTime",699,G__G__Net_279_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDatime",896,G__G__Net_279_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDatime",896,G__G__Net_279_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimestamp",1248,G__G__Net_279_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTimestamp",1248,G__G__Net_279_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeFormating",1634,G__G__Net_279_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinary",913,G__G__Net_279_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - Y - - 0 - - "
"l - 'Long_t' 0 - - l - 'Long_t' 0 '0x1000' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,G__G__Net_279_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNumAffectedRows",1805,G__G__Net_279_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StoreResult",1164,G__G__Net_279_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNumFields",1191,G__G__Net_279_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFieldName",1157,G__G__Net_279_0_29, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetMaxFieldSize",1489,G__G__Net_279_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextResultRow",1366,G__G__Net_279_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsNull",599,G__G__Net_279_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInt",587,G__G__Net_279_0_33, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUInt",672,G__G__Net_279_0_34, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLong",688,G__G__Net_279_0_35, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLong64",794,G__G__Net_279_0_36, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetULong64",879,G__G__Net_279_0_37, 109, -1, G__defined_typename("ULong64_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDouble",891,G__G__Net_279_0_38, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetString",919,G__G__Net_279_0_39, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinary",901,G__G__Net_279_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - Y - - 1 - - "
"l - 'Long_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDate",670,G__G__Net_279_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTime",687,G__G__Net_279_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDatime",884,G__G__Net_279_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDatime",884,G__G__Net_279_0_44, 117, G__get_linked_tagnum(&G__G__NetLN_TDatime), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYear",689,G__G__Net_279_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMonth",806,G__G__Net_279_0_46, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDay",574,G__G__Net_279_0_47, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHour",702,G__G__Net_279_0_48, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinute",914,G__G__Net_279_0_49, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecond",892,G__G__Net_279_0_50, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimestamp",1236,G__G__Net_279_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTimestamp",1236,G__G__Net_279_0_52, 117, G__get_linked_tagnum(&G__G__NetLN_TDatime), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsError",710,G__G__Net_279_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorCode",1189,G__G__Net_279_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorMsg",1105,G__G__Net_279_0_55, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableErrorOutput",1762,G__G__Net_279_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_279_0_57, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLStatement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_279_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLStatement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_279_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLStatement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_279_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLStatement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_279_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_279_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLStatement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_279_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLStatement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_279_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLStatement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_279_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLStatement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSQLStatement", 1399, G__G__Net_279_0_69, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_279_0_70, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLStatement), -1, 1, 1, 1, 1, 0, "u 'TSQLStatement' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSQLTableInfo(void) {
   /* TSQLTableInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
   G__memfunc_setup("TSQLTableInfo",1208,G__G__Net_280_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSQLTableInfo",1208,G__G__Net_280_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 6, 1, 1, 0, 
"C - - 10 - tablename U 'TList' - 0 - columns "
"C - - 10 '\"SQL table\"' comment C - - 10 '0' engine "
"C - - 10 '0' create_time C - - 10 '0' update_time", (char*)NULL, (void*) NULL, 0);
   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("GetColumns",1025,G__G__Net_280_0_4, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindColumn",1007,G__G__Net_280_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - columnname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEngine",886,G__G__Net_280_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCreateTime",1283,G__G__Net_280_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpdateTime",1298,G__G__Net_280_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Net_280_0_9, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLTableInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_280_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLTableInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_280_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLTableInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_280_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLTableInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_280_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_280_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLTableInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_280_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLTableInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_280_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLTableInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_280_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLTableInfo::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSQLTableInfo", 1208, G__G__Net_280_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 1, 1, 1, 0, "u 'TSQLTableInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSQLTableInfo", 1334, G__G__Net_280_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Net_280_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 1, 1, 1, 1, 0, "u 'TSQLTableInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTWebFile(void) {
   /* TWebFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile));
   G__memfunc_setup("TWebFile",754,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TWebFile), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - readHeadOnly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckProxy",1024,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BasicAuthentication",1954,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHead",658,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLine",680,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
"U 'TSocket' - 0 - s C - - 0 - line "
"i - 'Int_t' 0 - maxsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHunk",694,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
"U 'TSocket' - 0 - s C - - 0 - hunk "
"i - 'Int_t' 0 - maxsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HttpTerminator",1477,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 3, 1, 4, 1, 
"C - - 10 - start C - - 10 - peeked "
"i - 'Int_t' 0 - peeklen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFromWeb",978,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len "
"u 'TString' - 11 - msg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFromWeb10",1075,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len "
"u 'TString' - 11 - msg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBuffer10",1079,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBuffers10",1194,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 4, 0, 
"C - - 0 - buf N - 'Long64_t' 0 - pos "
"I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMsgReadBuffer10",1674,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"C - - 10 '0' redirectLocation g - 'Bool_t' 0 'kFALSE' tempRedirect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TWebFile",754,G__G__Net_283_0_14, 105, G__get_linked_tagnum(&G__G__NetLN_TWebFile), -1, 0, 2, 1, 1, 0, 
"C - - 10 - url C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TWebFile",754,G__G__Net_283_0_15, 105, G__get_linked_tagnum(&G__G__NetLN_TWebFile), -1, 0, 2, 1, 1, 0, 
"u 'TUrl' - 0 - url C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOpen",590,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReOpen",585,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffers",1097,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"C - - 0 - buf N - 'Long64_t' 0 - pos "
"I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Seek",392,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - offset i 'TFile::ERelativeTo' - 0 'kBeg' pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProxy",846,G__G__Net_283_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - url", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TWebFile::SetProxy) ), 0);
   G__memfunc_setup("GetProxy",834,G__G__Net_283_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::GetProxy) ), 0);
   G__memfunc_setup("Class",502,G__G__Net_283_0_25, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TWebFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_283_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_283_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TWebFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_283_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TWebFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_283_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_283_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_283_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_283_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_283_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TWebFile", 880, G__G__Net_283_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTWebSystem(void) {
   /* TWebSystem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem));
   G__memfunc_setup("GetDirPtr",885,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TWebSystem",1015,G__G__Net_284_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TWebSystem), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeDirectory",1331,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenDirectory",1351,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeDirectory",1335,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - dirp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirEntry",1105,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 - dirp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPathInfo",1081,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - path u 'FileStat_t' - 1 - buf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AccessPathName",1376,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - path i 'EAccessMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unlink",625,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Net_284_0_10, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TWebSystem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Net_284_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebSystem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Net_284_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TWebSystem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Net_284_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TWebSystem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_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__Net_284_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Net_284_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebSystem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Net_284_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebSystem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Net_284_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebSystem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Net_284_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebSystem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TWebSystem", 1141, G__G__Net_284_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Net() {
}

/*********************************************************
* 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__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_ZIP=536870912",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_ACK=268435456",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_ANY=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_OK=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_NOTOK=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_STRING=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_OBJECT=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_CINT=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_STREAMERINFO=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_PROCESSID=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GROUPVIEW=1000",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STOP=1001",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_FATAL=1002",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LOGLEVEL=1003",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LOGFILE=1004",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LOGDONE=1005",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STATUS=1006",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PING=1007",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PRINT=1008",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_RESET=1009",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETOBJECT=1010",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETPACKET=1011",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_CHECKFILE=1012",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SENDFILE=1013",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PARALLEL=1014",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PROCESS=1015",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_OUTPUTLIST=1016",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_AUTOBIN=1017",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_CACHE=1018",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETENTRIES=1019",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PROGRESS=1020",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_FEEDBACK=1021",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STOPPROCESS=1022",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_HOSTAUTH=1023",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETSLAVEINFO=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETTREEHEADER=1025",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETOUTPUTLIST=1026",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETSTATS=1027",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETPARALLEL=1028",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_VALIDATE_DSET=1029",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_DATA_READY=1030",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_QUERYLIST=1031",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_RETRIEVE=1032",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_ARCHIVE=1033",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_REMOVE=1034",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STARTPROCESS=1035",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SETIDLE=1036",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_QUERYSUBMITTED=1037",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SESSIONTAG=1038",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_MAXQUERIES=1039",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_CLEANUPSESSION=1040",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SERVERSTARTED=1041",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_DATASETS=1042",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PACKAGE_LIST=1043",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_MESSAGE=1044",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LIB_INC_PATH=1045",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_WORKERLISTS=1046",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_DATASET_STATUS=1047",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_OUTPUTOBJECT=1048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SETENV=1049",0,(char*)NULL);
}

static void G__cpp_setup_global3() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_REALTIMELOG=1050",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_VERSARCHCOMP=1051",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_ENDINIT=1052",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_TOUCH=1053",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_FORK=1054",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GOASYNC=1055",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SUBMERGER=1056",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_USER=2000",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PASS=2001",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_AUTH=2002",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_FSTAT=2003",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_OPEN=2004",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PUT=2005",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GET=2006",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_FLUSH=2007",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CLOSE=2008",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_STAT=2009",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ACK=2010",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ERR=2011",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PROTOCOL=2012",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPUSER=2013",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPN=2014",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPG=2015",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPSALT=2016",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPA=2017",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPB=2018",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPRESPONSE=2019",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PUTFILE=2020",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GETFILE=2021",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CHDIR=2022",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_MKDIR=2023",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RMDIR=2024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_LSDIR=2025",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PWD=2026",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_MV=2027",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RM=2028",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CHMOD=2029",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_KRB5=2030",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PROTOCOL2=2031",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_BYE=2032",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GLOBUS=2033",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CLEANUP=2034",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SSH=2035",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RFIO=2036",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_NEGOTIA=2037",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RSAKEY=2038",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ENCRYPT=2039",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_OPENDIR=2040",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_FREEDIR=2041",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_DIRENTRY=2042",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ACCESS=2043",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GETS=2044",0,(char*)NULL);
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)(&gGrid),85,0,0,G__get_linked_tagnum(&G__G__NetLN_TGrid),-1,-1,1,"gGrid=",0,(char*)NULL);
   G__memvar_setup((void*)(&gGridJobStatusList),85,0,0,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),-1,-1,1,"gGridJobStatusList=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kSendBuffer=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kRecvBuffer=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kOobInline=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kKeepAlive=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kReuseAddr=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kNoDelay=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kNoBlock=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kProcessGroup=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kAtMark=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kBytesToRead=9",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kDefault=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kOob=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kPeek=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kDontBlock=3",0,(char*)NULL);
   G__memvar_setup((void*)(&kSrvAuth),98,0,1,-1,G__defined_typename("UChar_t"),-1,1,"kSrvAuth=",0,(char*)NULL);
   G__memvar_setup((void*)(&kSrvNoAuth),98,0,1,-1,G__defined_typename("UChar_t"),-1,1,"kSrvNoAuth=",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Net() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
}

/*********************************************************
* 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() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Net() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__NetLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TVirtualStreamerInfo = { "TVirtualStreamerInfo" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TProcessID = { "TProcessID" , 99 , -1 };
G__linked_taginfo G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TVirtualMutex = { "TVirtualMutex" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSignalHandler = { "TSignalHandler" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TApplication = { "TApplication" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__NetLN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TUrl = { "TUrl" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TBufferFile = { "TBufferFile" , 99 , -1 };
G__linked_taginfo G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__NetLN_EMessageTypes = { "EMessageTypes" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TBits = { "TBits" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TMessage = { "TMessage" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSocket = { "TSocket" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TPSocket = { "TPSocket" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TMonitor = { "TMonitor" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TRemoteObject = { "TRemoteObject" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TApplicationRemote = { "TApplicationRemote" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TApplicationRemotecLcLESendFileOpt = { "TApplicationRemote::ESendFileOpt" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TApplicationRemotecLcLEStatusBits = { "TApplicationRemote::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TApplicationServer = { "TApplicationServer" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TFileStager = { "TFileStager" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TInetAddress = { "TInetAddress" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSystem = { "TSystem" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TServerSocket = { "TServerSocket" , 99 , -1 };
G__linked_taginfo G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__NetLN_EAccessMode = { "EAccessMode" , 101 , -1 };
G__linked_taginfo G__G__NetLN_FileStat_t = { "FileStat_t" , 115 , -1 };
G__linked_taginfo G__G__NetLN_TFTP = { "TFTP" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TFTPcLcLdA = { "TFTP::$" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TEntryList = { "TEntryList" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TDSet = { "TDSet" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridResult = { "TGridResult" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TFileCollection = { "TFileCollection" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridCollection = { "TGridCollection" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridJobStatus = { "TGridJobStatus" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridJob = { "TGridJob" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridJDL = { "TGridJDL" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridJobStatusList = { "TGridJobStatusList" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGrid = { "TGrid" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TGridJobStatuscLcLEGridJobStatus = { "TGridJobStatus::EGridJobStatus" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TMonitorcLcLEInterest = { "TMonitor::EInterest" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TDatime = { "TDatime" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TDirectoryFile = { "TDirectoryFile" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TFilecLcLERelativeTo = { "TFile::ERelativeTo" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TNetFile = { "TNetFile" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TNetSystem = { "TNetSystem" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSecContext = { "TSecContext" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSecContextCleanup = { "TSecContextCleanup" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TTimeStamp = { "TTimeStamp" , 99 , -1 };
G__linked_taginfo G__G__NetLN_ESockOptions = { "ESockOptions" , 101 , -1 };
G__linked_taginfo G__G__NetLN_ESendRecvOptions = { "ESendRecvOptions" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TSocketcLcLEStatusBits = { "TSocket::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TSocketcLcLEInterest = { "TSocket::EInterest" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TSocketcLcLEServiceType = { "TSocket::EServiceType" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TServerSocketcLcLdA = { "TServerSocket::$" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TPServerSocket = { "TPServerSocket" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLColumnInfo = { "TSQLColumnInfo" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TVirtualMonitoringWriter = { "TVirtualMonitoringWriter" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLServer = { "TSQLServer" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLMonitoringWriter = { "TSQLMonitoringWriter" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLRow = { "TSQLRow" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLResult = { "TSQLResult" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLStatement = { "TSQLStatement" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLTableInfo = { "TSQLTableInfo" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TSQLServercLcLESQLDataTypes = { "TSQLServer::ESQLDataTypes" , 101 , -1 };
G__linked_taginfo G__G__NetLN_TWebFile = { "TWebFile" , 99 , -1 };
G__linked_taginfo G__G__NetLN_TWebSystem = { "TWebSystem" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Net() {
  G__G__NetLN_TClass.tagnum = -1 ;
  G__G__NetLN_TBuffer.tagnum = -1 ;
  G__G__NetLN_TDirectory.tagnum = -1 ;
  G__G__NetLN_TMemberInspector.tagnum = -1 ;
  G__G__NetLN_TObject.tagnum = -1 ;
  G__G__NetLN_TNamed.tagnum = -1 ;
  G__G__NetLN_TString.tagnum = -1 ;
  G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__NetLN_TList.tagnum = -1 ;
  G__G__NetLN_TBrowser.tagnum = -1 ;
  G__G__NetLN_TVirtualStreamerInfo.tagnum = -1 ;
  G__G__NetLN_TProcessID.tagnum = -1 ;
  G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__NetLN_TVirtualMutex.tagnum = -1 ;
  G__G__NetLN_TQObject.tagnum = -1 ;
  G__G__NetLN_TSignalHandler.tagnum = -1 ;
  G__G__NetLN_TApplication.tagnum = -1 ;
  G__G__NetLN_TCollection.tagnum = -1 ;
  G__G__NetLN_TMap.tagnum = -1 ;
  G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__NetLN_THashList.tagnum = -1 ;
  G__G__NetLN_TUrl.tagnum = -1 ;
  G__G__NetLN_TBufferFile.tagnum = -1 ;
  G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__NetLN_EMessageTypes.tagnum = -1 ;
  G__G__NetLN_TBits.tagnum = -1 ;
  G__G__NetLN_TMessage.tagnum = -1 ;
  G__G__NetLN_TSocket.tagnum = -1 ;
  G__G__NetLN_TPSocket.tagnum = -1 ;
  G__G__NetLN_TMonitor.tagnum = -1 ;
  G__G__NetLN_TRemoteObject.tagnum = -1 ;
  G__G__NetLN_TSeqCollection.tagnum = -1 ;
  G__G__NetLN_TApplicationRemote.tagnum = -1 ;
  G__G__NetLN_TApplicationRemotecLcLESendFileOpt.tagnum = -1 ;
  G__G__NetLN_TApplicationRemotecLcLEStatusBits.tagnum = -1 ;
  G__G__NetLN_TApplicationServer.tagnum = -1 ;
  G__G__NetLN_TFileStager.tagnum = -1 ;
  G__G__NetLN_TInetAddress.tagnum = -1 ;
  G__G__NetLN_TSystem.tagnum = -1 ;
  G__G__NetLN_TServerSocket.tagnum = -1 ;
  G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__NetLN_EAccessMode.tagnum = -1 ;
  G__G__NetLN_FileStat_t.tagnum = -1 ;
  G__G__NetLN_TFTP.tagnum = -1 ;
  G__G__NetLN_TFTPcLcLdA.tagnum = -1 ;
  G__G__NetLN_TFile.tagnum = -1 ;
  G__G__NetLN_TEntryList.tagnum = -1 ;
  G__G__NetLN_TDSet.tagnum = -1 ;
  G__G__NetLN_TGridResult.tagnum = -1 ;
  G__G__NetLN_TFileCollection.tagnum = -1 ;
  G__G__NetLN_TGridCollection.tagnum = -1 ;
  G__G__NetLN_TGridJobStatus.tagnum = -1 ;
  G__G__NetLN_TGridJob.tagnum = -1 ;
  G__G__NetLN_TGridJDL.tagnum = -1 ;
  G__G__NetLN_TGridJobStatusList.tagnum = -1 ;
  G__G__NetLN_TGrid.tagnum = -1 ;
  G__G__NetLN_TGridJobStatuscLcLEGridJobStatus.tagnum = -1 ;
  G__G__NetLN_TMonitorcLcLEInterest.tagnum = -1 ;
  G__G__NetLN_TDatime.tagnum = -1 ;
  G__G__NetLN_TDirectoryFile.tagnum = -1 ;
  G__G__NetLN_TFilecLcLERelativeTo.tagnum = -1 ;
  G__G__NetLN_TNetFile.tagnum = -1 ;
  G__G__NetLN_TNetSystem.tagnum = -1 ;
  G__G__NetLN_TSecContext.tagnum = -1 ;
  G__G__NetLN_TSecContextCleanup.tagnum = -1 ;
  G__G__NetLN_TTimeStamp.tagnum = -1 ;
  G__G__NetLN_ESockOptions.tagnum = -1 ;
  G__G__NetLN_ESendRecvOptions.tagnum = -1 ;
  G__G__NetLN_TSocketcLcLEStatusBits.tagnum = -1 ;
  G__G__NetLN_TSocketcLcLEInterest.tagnum = -1 ;
  G__G__NetLN_TSocketcLcLEServiceType.tagnum = -1 ;
  G__G__NetLN_TServerSocketcLcLdA.tagnum = -1 ;
  G__G__NetLN_TPServerSocket.tagnum = -1 ;
  G__G__NetLN_TSQLColumnInfo.tagnum = -1 ;
  G__G__NetLN_TVirtualMonitoringWriter.tagnum = -1 ;
  G__G__NetLN_TSQLServer.tagnum = -1 ;
  G__G__NetLN_TSQLMonitoringWriter.tagnum = -1 ;
  G__G__NetLN_TSQLRow.tagnum = -1 ;
  G__G__NetLN_TSQLResult.tagnum = -1 ;
  G__G__NetLN_TSQLStatement.tagnum = -1 ;
  G__G__NetLN_TSQLTableInfo.tagnum = -1 ;
  G__G__NetLN_TSQLServercLcLESQLDataTypes.tagnum = -1 ;
  G__G__NetLN_TWebFile.tagnum = -1 ;
  G__G__NetLN_TWebSystem.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Net() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__NetLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TString);
   G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TList);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TVirtualStreamerInfo);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TProcessID);
   G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TVirtualMutex);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSignalHandler);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TApplication);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TCollection);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TMap);
   G__get_linked_tagnum_fwd(&G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_THashList);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TUrl);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TBufferFile);
   G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_EMessageTypes),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TMessage),sizeof(TMessage),-1,65280,"Message buffer class",G__setup_memvarTMessage,G__setup_memfuncTMessage);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSocket),sizeof(TSocket),-1,65280,"This class implements client sockets",G__setup_memvarTSocket,G__setup_memfuncTSocket);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TPSocket),sizeof(TPSocket),-1,65024,"Parallel client socket",G__setup_memvarTPSocket,G__setup_memfuncTPSocket);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TMonitor),sizeof(TMonitor),-1,30464,"Monitor activity on a set of TSocket objects",G__setup_memvarTMonitor,G__setup_memfuncTMonitor);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TRemoteObject);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSeqCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationRemote),sizeof(TApplicationRemote),-1,62464,"Remote Application Interface",G__setup_memvarTApplicationRemote,G__setup_memfuncTApplicationRemote);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationRemotecLcLEStatusBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationServer),sizeof(TApplicationServer),-1,62464,"Remote Application Interface",G__setup_memvarTApplicationServer,G__setup_memfuncTApplicationServer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TFileStager),sizeof(TFileStager),-1,62464,"ABC defining interface to a stager",G__setup_memvarTFileStager,G__setup_memfuncTFileStager);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TInetAddress);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSystem);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TServerSocket),sizeof(TServerSocket),-1,65280,"This class implements server sockets",G__setup_memvarTServerSocket,G__setup_memfuncTServerSocket);
   G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__NetLN_EAccessMode);
   G__get_linked_tagnum_fwd(&G__G__NetLN_FileStat_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TFTP),sizeof(TFTP),-1,65280,"File Transfer Protocol class using rootd",G__setup_memvarTFTP,G__setup_memfuncTFTP);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TFTPcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TFile);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TEntryList);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TDSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridResult),sizeof(TGridResult),-1,324864,"ABC defining interface to GRID result set",G__setup_memvarTGridResult,G__setup_memfuncTGridResult);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TFileCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridCollection),sizeof(TGridCollection),-1,292096,"ABC managing collection of files on the Grid",G__setup_memvarTGridCollection,G__setup_memfuncTGridCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJobStatus),sizeof(TGridJobStatus),-1,324865,"ABC defining status of a Grid job",G__setup_memvarTGridJobStatus,G__setup_memfuncTGridJobStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJob),sizeof(TGridJob),-1,324611,"ABC defining interface to a GRID job",G__setup_memvarTGridJob,G__setup_memfuncTGridJob);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJDL),sizeof(TGridJDL),-1,292115,"ABC defining interface JDL generator",G__setup_memvarTGridJDL,G__setup_memfuncTGridJDL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJobStatusList),sizeof(TGridJobStatusList),-1,324864,"ABC defining interface to a list of GRID jobs",G__setup_memvarTGridJobStatusList,G__setup_memfuncTGridJobStatusList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGrid),sizeof(TGrid),-1,29952,"ABC defining interface to GRID services",G__setup_memvarTGrid,G__setup_memfuncTGrid);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TMonitorcLcLEInterest);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TDatime);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TDirectoryFile);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TFilecLcLERelativeTo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TNetFile),sizeof(TNetFile),-1,65280,"A ROOT file that reads/writes via a rootd server",G__setup_memvarTNetFile,G__setup_memfuncTNetFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TNetSystem),sizeof(TNetSystem),-1,65280,"Directory handler for NetSystem",G__setup_memvarTNetSystem,G__setup_memfuncTNetSystem);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSecContext),sizeof(TSecContext),-1,65024,"Class providing host specific authentication information",G__setup_memvarTSecContext,G__setup_memfuncTSecContext);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSecContextCleanup),sizeof(TSecContextCleanup),-1,62464,"Update the remote authentication table",G__setup_memvarTSecContextCleanup,G__setup_memfuncTSecContextCleanup);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TTimeStamp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_ESockOptions),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_ESendRecvOptions),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSocketcLcLEStatusBits);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSocketcLcLEInterest);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSocketcLcLEServiceType);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TServerSocketcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TPServerSocket),sizeof(TPServerSocket),-1,65024,"Parallel server socket",G__setup_memvarTPServerSocket,G__setup_memfuncTPServerSocket);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLColumnInfo),sizeof(TSQLColumnInfo),-1,62720,"Summury information about column from SQL table",G__setup_memvarTSQLColumnInfo,G__setup_memfuncTSQLColumnInfo);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TVirtualMonitoringWriter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLServer),sizeof(TSQLServer),-1,29963,"Connection to SQL server",G__setup_memvarTSQLServer,G__setup_memfuncTSQLServer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLMonitoringWriter),sizeof(TSQLMonitoringWriter),-1,65024,"Sending monitoring data to a SQL DB",G__setup_memvarTSQLMonitoringWriter,G__setup_memfuncTSQLMonitoringWriter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLRow),sizeof(TSQLRow),-1,29955,"One row of an SQL query result",G__setup_memvarTSQLRow,G__setup_memfuncTSQLRow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLResult),sizeof(TSQLResult),-1,29956,"SQL query result",G__setup_memvarTSQLResult,G__setup_memfuncTSQLResult);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLStatement),sizeof(TSQLStatement),-1,29960,"SQL statement",G__setup_memvarTSQLStatement,G__setup_memfuncTSQLStatement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLTableInfo),sizeof(TSQLTableInfo),-1,62720,"Summury information about SQL table",G__setup_memvarTSQLTableInfo,G__setup_memfuncTSQLTableInfo);
   G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLServercLcLESQLDataTypes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TWebFile),sizeof(TWebFile),-1,62720,"A ROOT file that reads via a http server",G__setup_memvarTWebFile,G__setup_memfuncTWebFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TWebSystem),sizeof(TWebSystem),-1,62720,"Directory handler for HTTP (TWebFiles)",G__setup_memvarTWebSystem,G__setup_memfuncTWebSystem);
}
extern "C" void G__cpp_setupG__Net(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Net()");
  G__set_cpp_environmentG__Net();
  G__cpp_setup_tagtableG__Net();

  G__cpp_setup_inheritanceG__Net();

  G__cpp_setup_typetableG__Net();

  G__cpp_setup_memvarG__Net();

  G__cpp_setup_memfuncG__Net();
  G__cpp_setup_globalG__Net();
  G__cpp_setup_funcG__Net();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Net();
  return;
}
class G__cpp_setup_initG__Net {
  public:
    G__cpp_setup_initG__Net() { G__add_setup_func("G__Net",(G__incsetup)(&G__cpp_setupG__Net)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Net() { G__remove_setup_func("G__Net"); }
};
G__cpp_setup_initG__Net G__cpp_setup_initializerG__Net;

---