//
// File generated by core/utils/src/rootcint_tmp at Tue May 13 12:36:31 2014

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

#define R__DICTIONARY_FILENAME proofdIproofplayerdIsrcdIG__ProofPlayer
#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__ProofPlayer.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"
#include "TFileMergeInfo.h"

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

// START OF SHADOWS

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

namespace ROOT {
   void TDrawFeedback_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDrawFeedback(void *p = 0);
   static void *newArray_TDrawFeedback(Long_t size, void *p);
   static void delete_TDrawFeedback(void *p);
   static void deleteArray_TDrawFeedback(void *p);
   static void destruct_TDrawFeedback(void *p);

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

namespace ROOT {
   void TEventIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEventIter(void *p);
   static void deleteArray_TEventIter(void *p);
   static void destruct_TEventIter(void *p);

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

namespace ROOT {
   void TEventIterUnit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEventIterUnit(void *p = 0);
   static void *newArray_TEventIterUnit(Long_t size, void *p);
   static void delete_TEventIterUnit(void *p);
   static void deleteArray_TEventIterUnit(void *p);
   static void destruct_TEventIterUnit(void *p);

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

namespace ROOT {
   void TEventIterObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEventIterObj(void *p = 0);
   static void *newArray_TEventIterObj(Long_t size, void *p);
   static void delete_TEventIterObj(void *p);
   static void deleteArray_TEventIterObj(void *p);
   static void destruct_TEventIterObj(void *p);

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

namespace ROOT {
   void TEventIterTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEventIterTree(void *p = 0);
   static void *newArray_TEventIterTree(Long_t size, void *p);
   static void delete_TEventIterTree(void *p);
   static void deleteArray_TEventIterTree(void *p);
   static void destruct_TEventIterTree(void *p);

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

namespace ROOT {
   void TOutputListSelectorDataMap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TOutputListSelectorDataMap(void *p = 0);
   static void *newArray_TOutputListSelectorDataMap(Long_t size, void *p);
   static void delete_TOutputListSelectorDataMap(void *p);
   static void deleteArray_TOutputListSelectorDataMap(void *p);
   static void destruct_TOutputListSelectorDataMap(void *p);

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

namespace ROOT {
   void TVirtualPacketizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualPacketizer(void *p);
   static void deleteArray_TVirtualPacketizer(void *p);
   static void destruct_TVirtualPacketizer(void *p);

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

namespace ROOT {
   void TPacketizerAdaptive_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPacketizerAdaptive(void *p);
   static void deleteArray_TPacketizerAdaptive(void *p);
   static void destruct_TPacketizerAdaptive(void *p);

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

namespace ROOT {
   void TPacketizerFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPacketizerFile(void *p);
   static void deleteArray_TPacketizerFile(void *p);
   static void destruct_TPacketizerFile(void *p);

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

namespace ROOT {
   void TPacketizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPacketizer(void *p);
   static void deleteArray_TPacketizer(void *p);
   static void destruct_TPacketizer(void *p);

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

namespace ROOT {
   void TPacketizerMulti_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPacketizerMulti(void *p);
   static void deleteArray_TPacketizerMulti(void *p);
   static void destruct_TPacketizerMulti(void *p);

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

namespace ROOT {
   void TPacketizerUnit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPacketizerUnit(void *p);
   static void deleteArray_TPacketizerUnit(void *p);
   static void destruct_TPacketizerUnit(void *p);

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

namespace ROOT {
   void TPerfEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPerfEvent(void *p = 0);
   static void *newArray_TPerfEvent(Long_t size, void *p);
   static void delete_TPerfEvent(void *p);
   static void deleteArray_TPerfEvent(void *p);
   static void destruct_TPerfEvent(void *p);

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

namespace ROOT {
   void TPerfStats_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPerfStats(void *p);
   static void deleteArray_TPerfStats(void *p);
   static void destruct_TPerfStats(void *p);
   static void streamer_TPerfStats(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TProofMonSender_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofMonSender(void *p);
   static void deleteArray_TProofMonSender(void *p);
   static void destruct_TProofMonSender(void *p);

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

namespace ROOT {
   void TProofLimitsFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofLimitsFinder(void *p = 0);
   static void *newArray_TProofLimitsFinder(Long_t size, void *p);
   static void delete_TProofLimitsFinder(void *p);
   static void deleteArray_TProofLimitsFinder(void *p);
   static void destruct_TProofLimitsFinder(void *p);
   static void streamer_TProofLimitsFinder(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TProofMonSenderML_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofMonSenderML(void *p);
   static void deleteArray_TProofMonSenderML(void *p);
   static void destruct_TProofMonSenderML(void *p);

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

namespace ROOT {
   void TProofMonSenderSQL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofMonSenderSQL(void *p);
   static void deleteArray_TProofMonSenderSQL(void *p);
   static void destruct_TProofMonSenderSQL(void *p);

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

namespace ROOT {
   void TProofPlayerLite_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofPlayerLite(void *p = 0);
   static void *newArray_TProofPlayerLite(Long_t size, void *p);
   static void delete_TProofPlayerLite(void *p);
   static void deleteArray_TProofPlayerLite(void *p);
   static void destruct_TProofPlayerLite(void *p);

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

namespace ROOT {
   void TProofPlayerRemote_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofPlayerRemote(void *p = 0);
   static void *newArray_TProofPlayerRemote(Long_t size, void *p);
   static void delete_TProofPlayerRemote(void *p);
   static void deleteArray_TProofPlayerRemote(void *p);
   static void destruct_TProofPlayerRemote(void *p);

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

namespace ROOT {
   void TStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStatus(void *p = 0);
   static void *newArray_TStatus(Long_t size, void *p);
   static void delete_TStatus(void *p);
   static void deleteArray_TStatus(void *p);
   static void destruct_TStatus(void *p);
   static void streamer_TStatus(TBuffer &buf, void *obj);
   static Long64_t merge_TStatus(void *obj, TCollection *coll,TFileMergeInfo *info);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStatus*)
   {
      ::TStatus *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStatus >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStatus", ::TStatus::Class_Version(), "include/TStatus.h", 39,
                  typeid(::TStatus), DefineBehavior(ptr, ptr),
                  &::TStatus::Dictionary, isa_proxy, 1,
                  sizeof(::TStatus) );
      instance.SetNew(&new_TStatus);
      instance.SetNewArray(&newArray_TStatus);
      instance.SetDelete(&delete_TStatus);
      instance.SetDeleteArray(&deleteArray_TStatus);
      instance.SetDestructor(&destruct_TStatus);
      instance.SetStreamerFunc(&streamer_TStatus);
      instance.SetMerge(&merge_TStatus);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStatus*)
   {
      return GenerateInitInstanceLocal((::TStatus*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TProofPlayer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofPlayer(void *p = 0);
   static void *newArray_TProofPlayer(Long_t size, void *p);
   static void delete_TProofPlayer(void *p);
   static void deleteArray_TProofPlayer(void *p);
   static void destruct_TProofPlayer(void *p);

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

namespace ROOT {
   void TProofPlayerLocal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofPlayerLocal(void *p = 0);
   static void *newArray_TProofPlayerLocal(Long_t size, void *p);
   static void delete_TProofPlayerLocal(void *p);
   static void deleteArray_TProofPlayerLocal(void *p);
   static void destruct_TProofPlayerLocal(void *p);

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

namespace ROOT {
   void TProofPlayerSlave_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofPlayerSlave(void *p = 0);
   static void *newArray_TProofPlayerSlave(Long_t size, void *p);
   static void delete_TProofPlayerSlave(void *p);
   static void deleteArray_TProofPlayerSlave(void *p);
   static void destruct_TProofPlayerSlave(void *p);

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

namespace ROOT {
   void TProofPlayerSuperMaster_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofPlayerSuperMaster(void *p = 0);
   static void *newArray_TProofPlayerSuperMaster(Long_t size, void *p);
   static void delete_TProofPlayerSuperMaster(void *p);
   static void deleteArray_TProofPlayerSuperMaster(void *p);
   static void destruct_TProofPlayerSuperMaster(void *p);

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

namespace ROOT {
   void TStatsFeedback_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStatsFeedback(void *p = 0);
   static void *newArray_TStatsFeedback(Long_t size, void *p);
   static void delete_TStatsFeedback(void *p);
   static void deleteArray_TStatsFeedback(void *p);
   static void destruct_TStatsFeedback(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void TProofPlayer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofPlayer.
      TClass *R__cl = ::TProofPlayer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoBins", &fAutoBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInput", &fInput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutput", &fOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelector", &fSelector);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreateSelObj", &fCreateSelObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectorClass", &fSelectorClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedbackTimer", &fFeedbackTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFeedbackPeriod", &fFeedbackPeriod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvIter", &fEvIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelStatus", &fSelStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExitStatus", &fExitStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalEvents", &fTotalEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressStatus", &fProgressStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadBytesRun", &fReadBytesRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadCallsRun", &fReadCallsRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcessedRun", &fProcessedRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueryResults", &fQueryResults);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQuery", &fQuery);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviousQuery", &fPreviousQuery);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawQueries", &fDrawQueries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDrawQueries", &fMaxDrawQueries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopTimer", &fStopTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopTimerMtx", &fStopTimerMtx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDispatchTimer", &fDispatchTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcTimeTimer", &fProcTimeTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcTime", &fProcTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutputFilePath", &fOutputFilePath);
      R__insp.InspectMember(fOutputFilePath, "fOutputFilePath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutputFile", &fOutputFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveMemThreshold", &fSaveMemThreshold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSavePartialResults", &fSavePartialResults);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveResultsPerPacket", &fSaveResultsPerPacket);
      TVirtualProofPlayer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofPlayer(void *p) {
      return  p ? new(p) ::TProofPlayer : new ::TProofPlayer;
   }
   static void *newArray_TProofPlayer(Long_t nElements, void *p) {
      return p ? new(p) ::TProofPlayer[nElements] : new ::TProofPlayer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofPlayer(void *p) {
      delete ((::TProofPlayer*)p);
   }
   static void deleteArray_TProofPlayer(void *p) {
      delete [] ((::TProofPlayer*)p);
   }
   static void destruct_TProofPlayer(void *p) {
      typedef ::TProofPlayer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofPlayer

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofPlayerLite(void *p) {
      return  p ? new(p) ::TProofPlayerLite : new ::TProofPlayerLite;
   }
   static void *newArray_TProofPlayerLite(Long_t nElements, void *p) {
      return p ? new(p) ::TProofPlayerLite[nElements] : new ::TProofPlayerLite[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofPlayerLite(void *p) {
      delete ((::TProofPlayerLite*)p);
   }
   static void deleteArray_TProofPlayerLite(void *p) {
      delete [] ((::TProofPlayerLite*)p);
   }
   static void destruct_TProofPlayerLite(void *p) {
      typedef ::TProofPlayerLite current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofPlayerLite

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofPlayerLocal(void *p) {
      return  p ? new(p) ::TProofPlayerLocal : new ::TProofPlayerLocal;
   }
   static void *newArray_TProofPlayerLocal(Long_t nElements, void *p) {
      return p ? new(p) ::TProofPlayerLocal[nElements] : new ::TProofPlayerLocal[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofPlayerLocal(void *p) {
      delete ((::TProofPlayerLocal*)p);
   }
   static void deleteArray_TProofPlayerLocal(void *p) {
      delete [] ((::TProofPlayerLocal*)p);
   }
   static void destruct_TProofPlayerLocal(void *p) {
      typedef ::TProofPlayerLocal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofPlayerLocal

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

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

//______________________________________________________________________________
void TProofPlayerRemote::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofPlayerRemote.
      TClass *R__cl = ::TProofPlayerRemote::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutputLists", &fOutputLists);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedback", &fFeedback);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedbackLists", &fFeedbackLists);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPacketizer", &fPacketizer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergeFiles", &fMergeFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDSet", &fDSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrorHandler", &fErrorHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergeTH1OneByOne", &fMergeTH1OneByOne);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcPackets", &fProcPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcessMessage", &fProcessMessage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectorFileName", &fSelectorFileName);
      R__insp.InspectMember(fSelectorFileName, "fSelectorFileName.");
      TProofPlayer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofPlayerRemote(void *p) {
      return  p ? new(p) ::TProofPlayerRemote : new ::TProofPlayerRemote;
   }
   static void *newArray_TProofPlayerRemote(Long_t nElements, void *p) {
      return p ? new(p) ::TProofPlayerRemote[nElements] : new ::TProofPlayerRemote[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofPlayerRemote(void *p) {
      delete ((::TProofPlayerRemote*)p);
   }
   static void deleteArray_TProofPlayerRemote(void *p) {
      delete [] ((::TProofPlayerRemote*)p);
   }
   static void destruct_TProofPlayerRemote(void *p) {
      typedef ::TProofPlayerRemote current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofPlayerRemote

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofPlayerSlave(void *p) {
      return  p ? new(p) ::TProofPlayerSlave : new ::TProofPlayerSlave;
   }
   static void *newArray_TProofPlayerSlave(Long_t nElements, void *p) {
      return p ? new(p) ::TProofPlayerSlave[nElements] : new ::TProofPlayerSlave[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofPlayerSlave(void *p) {
      delete ((::TProofPlayerSlave*)p);
   }
   static void deleteArray_TProofPlayerSlave(void *p) {
      delete [] ((::TProofPlayerSlave*)p);
   }
   static void destruct_TProofPlayerSlave(void *p) {
      typedef ::TProofPlayerSlave current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofPlayerSlave

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

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

//______________________________________________________________________________
void TProofPlayerSuperMaster::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofPlayerSuperMaster.
      TClass *R__cl = ::TProofPlayerSuperMaster::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveProgress", &fSlaveProgress);
      R__insp.InspectMember(fSlaveProgress, "fSlaveProgress.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveTotals", &fSlaveTotals);
      R__insp.InspectMember(fSlaveTotals, "fSlaveTotals.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveBytesRead", &fSlaveBytesRead);
      R__insp.InspectMember(fSlaveBytesRead, "fSlaveBytesRead.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveInitTime", &fSlaveInitTime);
      R__insp.InspectMember(fSlaveInitTime, "fSlaveInitTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveProcTime", &fSlaveProcTime);
      R__insp.InspectMember(fSlaveProcTime, "fSlaveProcTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveEvtRti", &fSlaveEvtRti);
      R__insp.InspectMember(fSlaveEvtRti, "fSlaveEvtRti.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveMBRti", &fSlaveMBRti);
      R__insp.InspectMember(fSlaveMBRti, "fSlaveMBRti.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveActW", &fSlaveActW);
      R__insp.InspectMember(fSlaveActW, "fSlaveActW.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveTotS", &fSlaveTotS);
      R__insp.InspectMember(fSlaveTotS, "fSlaveTotS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveEffS", &fSlaveEffS);
      R__insp.InspectMember(fSlaveEffS, "fSlaveEffS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaves", &fSlaves);
      R__insp.InspectMember(fSlaves, "fSlaves.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReturnFeedback", &fReturnFeedback);
      TProofPlayerRemote::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofPlayerSuperMaster(void *p) {
      return  p ? new(p) ::TProofPlayerSuperMaster : new ::TProofPlayerSuperMaster;
   }
   static void *newArray_TProofPlayerSuperMaster(Long_t nElements, void *p) {
      return p ? new(p) ::TProofPlayerSuperMaster[nElements] : new ::TProofPlayerSuperMaster[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofPlayerSuperMaster(void *p) {
      delete ((::TProofPlayerSuperMaster*)p);
   }
   static void deleteArray_TProofPlayerSuperMaster(void *p) {
      delete [] ((::TProofPlayerSuperMaster*)p);
   }
   static void destruct_TProofPlayerSuperMaster(void *p) {
      typedef ::TProofPlayerSuperMaster current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofPlayerSuperMaster

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

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

//______________________________________________________________________________
void TVirtualPacketizer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualPacketizer.
      TClass *R__cl = ::TVirtualPacketizer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinPacketTime", &fMinPacketTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPacketTime", &fMaxPacketTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConfigParams", &fConfigParams);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaveStats", &fSlaveStats);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressStatus", &fProgressStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgress", &fProgress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalEntries", &fTotalEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFailedPackets", &fFailedPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartTime", &fStartTime);
      R__insp.InspectMember(fStartTime, "fStartTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitTime", &fInitTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeUpdt", &fTimeUpdt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCircProg", &fCircProg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCircN", &fCircN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressPerf", &fProgressPerf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTimeLast", &fProcTimeLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActWrksLast", &fActWrksLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtRateLast", &fEvtRateLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBsReadLast", &fMBsReadLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffSessLast", &fEffSessLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAWLastFill", &fAWLastFill);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReportPeriod", &fReportPeriod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseEstOpt", &fUseEstOpt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStop", &fStop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSet", &fDataSet);
      R__insp.InspectMember(fDataSet, "fDataSet.");
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualPacketizer(void *p) {
      delete ((::TVirtualPacketizer*)p);
   }
   static void deleteArray_TVirtualPacketizer(void *p) {
      delete [] ((::TVirtualPacketizer*)p);
   }
   static void destruct_TVirtualPacketizer(void *p) {
      typedef ::TVirtualPacketizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualPacketizer

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

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

//______________________________________________________________________________
void TPacketizer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPacketizer.
      TClass *R__cl = ::TPacketizer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileNodes", &fFileNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnAllocated", &fUnAllocated);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaveStats", &fSlaveStats);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketSize", &fPacketSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPerfIdx", &fMaxPerfIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSlaveCnt", &fMaxSlaveCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketAsAFraction", &fPacketAsAFraction);
      TVirtualPacketizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TPacketizer(void *p) {
      delete ((::TPacketizer*)p);
   }
   static void deleteArray_TPacketizer(void *p) {
      delete [] ((::TPacketizer*)p);
   }
   static void destruct_TPacketizer(void *p) {
      typedef ::TPacketizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPacketizer

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

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

//______________________________________________________________________________
void TPacketizerUnit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPacketizerUnit.
      TClass *R__cl = ::TPacketizerUnit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWrkStats", &fWrkStats);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWrkExcluded", &fWrkExcluded);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopwatch", &fStopwatch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcessing", &fProcessing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAssigned", &fAssigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalibFrac", &fCalibFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumPerWorker", &fNumPerWorker);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixedNum", &fFixedNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketSeq", &fPacketSeq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInput", &fInput);
      TVirtualPacketizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TPacketizerUnit(void *p) {
      delete ((::TPacketizerUnit*)p);
   }
   static void deleteArray_TPacketizerUnit(void *p) {
      delete [] ((::TPacketizerUnit*)p);
   }
   static void destruct_TPacketizerUnit(void *p) {
      typedef ::TPacketizerUnit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPacketizerUnit

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

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

//______________________________________________________________________________
void TPacketizerAdaptive::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPacketizerAdaptive.
      TClass *R__cl = ::TPacketizerAdaptive::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileNodes", &fFileNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnAllocated", &fUnAllocated);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPerfIdx", &fMaxPerfIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPartitions", &fPartitions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFilesToProcess", &fFilesToProcess);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCachePacketSync", &fCachePacketSync);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxEntriesRatio", &fMaxEntriesRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFractionOfRemoteFiles", &fFractionOfRemoteFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEventsOnRemLoc", &fNEventsOnRemLoc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaseLocalPreference", &fBaseLocalPreference);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForceLocal", &fForceLocal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSlaveCnt", &fMaxSlaveCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketAsAFraction", &fPacketAsAFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrategy", &fStrategy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTryReassign", &fTryReassign);
      TVirtualPacketizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TPacketizerAdaptive(void *p) {
      delete ((::TPacketizerAdaptive*)p);
   }
   static void deleteArray_TPacketizerAdaptive(void *p) {
      delete [] ((::TPacketizerAdaptive*)p);
   }
   static void destruct_TPacketizerAdaptive(void *p) {
      typedef ::TPacketizerAdaptive current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPacketizerAdaptive

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TPacketizerMulti(void *p) {
      delete ((::TPacketizerMulti*)p);
   }
   static void deleteArray_TPacketizerMulti(void *p) {
      delete [] ((::TPacketizerMulti*)p);
   }
   static void destruct_TPacketizerMulti(void *p) {
      typedef ::TPacketizerMulti current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPacketizerMulti

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

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

//______________________________________________________________________________
void TPacketizerFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPacketizerFile.
      TClass *R__cl = ::TPacketizerFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFiles", &fFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNotAssigned", &fNotAssigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIters", &fIters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAssigned", &fAssigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcNotAssigned", &fProcNotAssigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAddFileInfo", &fAddFileInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopwatch", &fStopwatch);
      TVirtualPacketizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TPacketizerFile(void *p) {
      delete ((::TPacketizerFile*)p);
   }
   static void deleteArray_TPacketizerFile(void *p) {
      delete [] ((::TPacketizerFile*)p);
   }
   static void destruct_TPacketizerFile(void *p) {
      typedef ::TPacketizerFile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPacketizerFile

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

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

//______________________________________________________________________________
void TEventIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEventIter.
      TClass *R__cl = ::TEventIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDSet", &fDSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElem", &fElem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilename", &fFilename);
      R__insp.InspectMember(fFilename, "fFilename.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldBytesRead", &fOldBytesRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPath", &fPath);
      R__insp.InspectMember(fPath, "fPath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDir", &fDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElemFirst", &fElemFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElemNum", &fElemNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElemCur", &fElemCur);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSel", &fSel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNum", &fNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCur", &fCur);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStop", &fStop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventList", &fEventList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventListPos", &fEventListPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryList", &fEntryList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryListPos", &fEntryListPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEventIter(void *p) {
      delete ((::TEventIter*)p);
   }
   static void deleteArray_TEventIter(void *p) {
      delete [] ((::TEventIter*)p);
   }
   static void destruct_TEventIter(void *p) {
      typedef ::TEventIter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEventIter

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEventIterUnit(void *p) {
      return  p ? new(p) ::TEventIterUnit : new ::TEventIterUnit;
   }
   static void *newArray_TEventIterUnit(Long_t nElements, void *p) {
      return p ? new(p) ::TEventIterUnit[nElements] : new ::TEventIterUnit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEventIterUnit(void *p) {
      delete ((::TEventIterUnit*)p);
   }
   static void deleteArray_TEventIterUnit(void *p) {
      delete [] ((::TEventIterUnit*)p);
   }
   static void destruct_TEventIterUnit(void *p) {
      typedef ::TEventIterUnit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEventIterUnit

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEventIterObj(void *p) {
      return  p ? new(p) ::TEventIterObj : new ::TEventIterObj;
   }
   static void *newArray_TEventIterObj(Long_t nElements, void *p) {
      return p ? new(p) ::TEventIterObj[nElements] : new ::TEventIterObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEventIterObj(void *p) {
      delete ((::TEventIterObj*)p);
   }
   static void deleteArray_TEventIterObj(void *p) {
      delete [] ((::TEventIterObj*)p);
   }
   static void destruct_TEventIterObj(void *p) {
      typedef ::TEventIterObj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEventIterObj

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

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

//______________________________________________________________________________
void TEventIterTree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEventIterTree.
      TClass *R__cl = ::TEventIterTree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeName", &fTreeName);
      R__insp.InspectMember(fTreeName, "fTreeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeCache", &fTreeCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeCacheIsLearning", &fTreeCacheIsLearning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseTreeCache", &fUseTreeCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheSize", &fCacheSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseParallelUnzip", &fUseParallelUnzip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDontCacheFiles", &fDontCacheFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileTrees", &fFileTrees);
      TEventIter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEventIterTree(void *p) {
      return  p ? new(p) ::TEventIterTree : new ::TEventIterTree;
   }
   static void *newArray_TEventIterTree(Long_t nElements, void *p) {
      return p ? new(p) ::TEventIterTree[nElements] : new ::TEventIterTree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEventIterTree(void *p) {
      delete ((::TEventIterTree*)p);
   }
   static void deleteArray_TEventIterTree(void *p) {
      delete [] ((::TEventIterTree*)p);
   }
   static void destruct_TEventIterTree(void *p) {
      typedef ::TEventIterTree current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEventIterTree

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

   TVirtualPerfStats::Streamer(R__b);
}

//______________________________________________________________________________
void TPerfStats::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPerfStats.
      TClass *R__cl = ::TPerfStats::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrace", &fTrace);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTzero", &fTzero);
      R__insp.InspectMember(fTzero, "fTzero.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPerfEvent", &fPerfEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPacketsHist", &fPacketsHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcPcktHist", &fProcPcktHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventsHist", &fEventsHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeHist", &fNodeHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLatencyHist", &fLatencyHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcTimeHist", &fProcTimeHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCpuTimeHist", &fCpuTimeHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotCpuTime", &fTotCpuTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotBytesRead", &fTotBytesRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotEvents", &fTotEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumEvents", &fNumEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaves", &fSlaves);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoHist", &fDoHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoTrace", &fDoTrace);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoTraceRate", &fDoTraceRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoSlaveTrace", &fDoSlaveTrace);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoQuota", &fDoQuota);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMonitorPerPacket", &fMonitorPerPacket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMonSenders", &fMonSenders);
      R__insp.InspectMember(fMonSenders, "fMonSenders.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSet", &fDataSet);
      R__insp.InspectMember(fDataSet, "fDataSet.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetLen", &fDataSetLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetSize", &fDataSetSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDSet", &fDSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutput", &fOutput);
      TVirtualPerfStats::ShowMembers(R__insp);
}

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

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

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

//______________________________________________________________________________
void TPerfEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPerfEvent.
      TClass *R__cl = ::TPerfEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtNode", &fEvtNode);
      R__insp.InspectMember(fEvtNode, "fEvtNode.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeStamp", &fTimeStamp);
      R__insp.InspectMember(fTimeStamp, "fTimeStamp.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveName", &fSlaveName);
      R__insp.InspectMember(fSlaveName, "fSlaveName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodeName", &fNodeName);
      R__insp.InspectMember(fNodeName, "fNodeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileName", &fFileName);
      R__insp.InspectMember(fFileName, "fFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileClass", &fFileClass);
      R__insp.InspectMember(fFileClass, "fFileClass.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlave", &fSlave);
      R__insp.InspectMember(fSlave, "fSlave.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventsProcessed", &fEventsProcessed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLen", &fLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatency", &fLatency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuTime", &fCpuTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsStart", &fIsStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOk", &fIsOk);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPerfEvent(void *p) {
      return  p ? new(p) ::TPerfEvent : new ::TPerfEvent;
   }
   static void *newArray_TPerfEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TPerfEvent[nElements] : new ::TPerfEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPerfEvent(void *p) {
      delete ((::TPerfEvent*)p);
   }
   static void deleteArray_TPerfEvent(void *p) {
      delete [] ((::TPerfEvent*)p);
   }
   static void destruct_TPerfEvent(void *p) {
      typedef ::TPerfEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPerfEvent

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TProofMonSender(void *p) {
      delete ((::TProofMonSender*)p);
   }
   static void deleteArray_TProofMonSender(void *p) {
      delete [] ((::TProofMonSender*)p);
   }
   static void destruct_TProofMonSender(void *p) {
      typedef ::TProofMonSender current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofMonSender

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TProofMonSenderML(void *p) {
      delete ((::TProofMonSenderML*)p);
   }
   static void deleteArray_TProofMonSenderML(void *p) {
      delete [] ((::TProofMonSenderML*)p);
   }
   static void destruct_TProofMonSenderML(void *p) {
      typedef ::TProofMonSenderML current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofMonSenderML

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TProofMonSenderSQL(void *p) {
      delete ((::TProofMonSenderSQL*)p);
   }
   static void deleteArray_TProofMonSenderSQL(void *p) {
      delete [] ((::TProofMonSenderSQL*)p);
   }
   static void destruct_TProofMonSenderSQL(void *p) {
      typedef ::TProofMonSenderSQL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProofMonSenderSQL

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

   THLimitsFinder::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProofLimitsFinder(void *p) {
      return  p ? new(p) ::TProofLimitsFinder : new ::TProofLimitsFinder;
   }
   static void *newArray_TProofLimitsFinder(Long_t nElements, void *p) {
      return p ? new(p) ::TProofLimitsFinder[nElements] : new ::TProofLimitsFinder[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofLimitsFinder(void *p) {
      delete ((::TProofLimitsFinder*)p);
   }
   static void deleteArray_TProofLimitsFinder(void *p) {
      delete [] ((::TProofLimitsFinder*)p);
   }
   static void destruct_TProofLimitsFinder(void *p) {
      typedef ::TProofLimitsFinder current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TProofLimitsFinder(TBuffer &buf, void *obj) {
      ((::TProofLimitsFinder*)obj)->::TProofLimitsFinder::Streamer(buf);
   }
} // end of namespace ROOT for class ::TProofLimitsFinder

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

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

//______________________________________________________________________________
void TDrawFeedback::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDrawFeedback.
      TClass *R__cl = ::TDrawFeedback::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(), "fAll", &fAll);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNames", &fNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOption", &fOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDrawFeedback(void *p) {
      return  p ? new(p) ::TDrawFeedback : new ::TDrawFeedback;
   }
   static void *newArray_TDrawFeedback(Long_t nElements, void *p) {
      return p ? new(p) ::TDrawFeedback[nElements] : new ::TDrawFeedback[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDrawFeedback(void *p) {
      delete ((::TDrawFeedback*)p);
   }
   static void deleteArray_TDrawFeedback(void *p) {
      delete [] ((::TDrawFeedback*)p);
   }
   static void destruct_TDrawFeedback(void *p) {
      typedef ::TDrawFeedback current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDrawFeedback

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

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

//______________________________________________________________________________
void TStatsFeedback::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStatsFeedback.
      TClass *R__cl = ::TStatsFeedback::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(), "*fProof", &fProof);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStatsFeedback(void *p) {
      return  p ? new(p) ::TStatsFeedback : new ::TStatsFeedback;
   }
   static void *newArray_TStatsFeedback(Long_t nElements, void *p) {
      return p ? new(p) ::TStatsFeedback[nElements] : new ::TStatsFeedback[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStatsFeedback(void *p) {
      delete ((::TStatsFeedback*)p);
   }
   static void deleteArray_TStatsFeedback(void *p) {
      delete [] ((::TStatsFeedback*)p);
   }
   static void destruct_TStatsFeedback(void *p) {
      typedef ::TStatsFeedback current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStatsFeedback

//______________________________________________________________________________
void TStatus::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStatus.
      TClass *R__cl = ::TStatus::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgs", &fMsgs);
      R__insp.InspectMember(fMsgs, "fMsgs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", &fIter);
      R__insp.InspectMember(fIter, "fIter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoMsgs", &fInfoMsgs);
      R__insp.InspectMember(fInfoMsgs, "fInfoMsgs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExitStatus", &fExitStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVirtMemMax", &fVirtMemMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResMemMax", &fResMemMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVirtMaxMst", &fVirtMaxMst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResMaxMst", &fResMaxMst);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStatus(void *p) {
      return  p ? new(p) ::TStatus : new ::TStatus;
   }
   static void *newArray_TStatus(Long_t nElements, void *p) {
      return p ? new(p) ::TStatus[nElements] : new ::TStatus[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStatus(void *p) {
      delete ((::TStatus*)p);
   }
   static void deleteArray_TStatus(void *p) {
      delete [] ((::TStatus*)p);
   }
   static void destruct_TStatus(void *p) {
      typedef ::TStatus current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStatus(TBuffer &buf, void *obj) {
      ((::TStatus*)obj)->::TStatus::Streamer(buf);
   }
   // Wrapper around the merge function.
   static Long64_t  merge_TStatus(void *obj,TCollection *coll,TFileMergeInfo *) {
      return ((::TStatus*)obj)->Merge(coll);
   }
} // end of namespace ROOT for class ::TStatus

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TOutputListSelectorDataMap(void *p) {
      return  p ? new(p) ::TOutputListSelectorDataMap : new ::TOutputListSelectorDataMap;
   }
   static void *newArray_TOutputListSelectorDataMap(Long_t nElements, void *p) {
      return p ? new(p) ::TOutputListSelectorDataMap[nElements] : new ::TOutputListSelectorDataMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TOutputListSelectorDataMap(void *p) {
      delete ((::TOutputListSelectorDataMap*)p);
   }
   static void deleteArray_TOutputListSelectorDataMap(void *p) {
      delete [] ((::TOutputListSelectorDataMap*)p);
   }
   static void destruct_TOutputListSelectorDataMap(void *p) {
      typedef ::TOutputListSelectorDataMap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TOutputListSelectorDataMap

/********************************************************
* proof/proofplayer/src/G__ProofPlayer.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__ProofPlayer();

extern "C" void G__set_cpp_environmentG__ProofPlayer() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TDrawFeedback.h");
  G__add_compiledheader("TEventIter.h");
  G__add_compiledheader("TOutputListSelectorDataMap.h");
  G__add_compiledheader("TPacketizerAdaptive.h");
  G__add_compiledheader("TPacketizerFile.h");
  G__add_compiledheader("TPacketizer.h");
  G__add_compiledheader("TPacketizerMulti.h");
  G__add_compiledheader("TPacketizerUnit.h");
  G__add_compiledheader("TPerfStats.h");
  G__add_compiledheader("TProofLimitsFinder.h");
  G__add_compiledheader("TProofMonSender.h");
  G__add_compiledheader("TProofMonSenderML.h");
  G__add_compiledheader("TProofMonSenderSQL.h");
  G__add_compiledheader("TProofPlayer.h");
  G__add_compiledheader("TProofPlayerLite.h");
  G__add_compiledheader("TStatsFeedback.h");
  G__add_compiledheader("TStatus.h");
  G__add_compiledheader("TVirtualPacketizer.h");
  G__cpp_reset_tagtableG__ProofPlayer();
}
#include <new>
extern "C" int G__cpp_dllrevG__ProofPlayer() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TEventIter */
static int G__G__ProofPlayer_138_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TEventIter*) G__getstructoffset())->GetCacheSize());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__ProofPlayer_138_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TEventIter*) G__getstructoffset())->GetNextEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_138_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 105, (long) ((TEventIter*) G__getstructoffset())->GetNextPacket(*(Long64_t*) G__Longlongref(&libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])
, (TEntryList**) G__int(libp->para[2]), (TEventList**) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TEventIter*) G__getstructoffset())->GetNextPacket(*(Long64_t*) G__Longlongref(&libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])
, (TEntryList**) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TEventIter*) G__getstructoffset())->GetNextPacket(*(Long64_t*) G__Longlongref(&libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__ProofPlayer_138_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEventIter::Create((TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__ProofPlayer_163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetEstEntriesProcessed((Float_t) G__double(libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])
, *(Long64_t*) G__Longlongref(&libp->para[2]), *(Long64_t*) G__Longlongref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TVirtualPacketizer*) G__getstructoffset())->GetCurrentRate(*(Bool_t*) G__Boolref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__ProofPlayer_163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetNextPacket((TSlave*) G__int(libp->para[0]), (TMessage*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__ProofPlayer_163_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualPacketizer*) G__getstructoffset())->MarkBad((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
, (TList**) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_163_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualPacketizer*) G__getstructoffset())->AddProcessed((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TList**) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TPacketizerAdaptive */
static int G__G__ProofPlayer_172_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPacketizerAdaptive* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPacketizerAdaptive(
(TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TPacketizerAdaptive(
(TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_172_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 105, (long) ((TPacketizerAdaptive*) G__getstructoffset())->AddProcessed((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TList**) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TPacketizerAdaptive*) G__getstructoffset())->AddProcessed((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_172_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPacketizerAdaptive*) G__getstructoffset())->CalculatePacketSize((TObject*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__ProofPlayer_187_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPacketizerFile*) G__getstructoffset())->GetCurrentTime());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TPacketizer */
static int G__G__ProofPlayer_190_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPacketizer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPacketizer(
(TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TPacketizer(
(TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_190_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TPacketizer*) G__getstructoffset())->GetEntriesProcessed((TSlave*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TPacketizerMulti */
static int G__G__ProofPlayer_194_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPacketizerMulti* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPacketizerMulti(
(TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TPacketizerMulti(
(TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__ProofPlayer_195_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPacketizerUnit*) G__getstructoffset())->AssignWork((TDSet*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_195_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TPacketizerUnit*) G__getstructoffset())->GetCurrentTime());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__ProofPlayer_210_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPerfStats::Stop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__ProofPlayer_210_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPerfStats::SetMemValues();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_210_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPerfStats::GetMemValues(*(Long_t*) G__Longref(&libp->para[0]), *(Long_t*) G__Longref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__ProofPlayer_211_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProofMonSender*) G__getstructoffset())->SendDataSetInfo((TDSet*) 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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_211_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProofMonSender*) G__getstructoffset())->SendFileInfo((TDSet*) 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])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__ProofPlayer_214_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProofLimitsFinder::AutoBinFunc(
*(TString*) libp->para[0].ref, *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__ProofPlayer_277_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProofPlayerRemote*) G__getstructoffset())->Incorporate((TObject*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
, *(Bool_t*) G__Boolref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_277_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TProofPlayerRemote*) G__getstructoffset())->HandleHistogram((TObject*) G__int(libp->para[0]), *(Bool_t*) G__Boolref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__ProofPlayer_286_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TProofPlayerLocal*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TProofPlayerLocal*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TProofPlayerLocal*) G__getstructoffset())->Process((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofPlayer_286_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TProofPlayerLocal*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TProofPlayerLocal*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TProofPlayerLocal*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TDrawFeedback */

/* TEventIter */

/* TEventIterUnit */

/* TEventIterObj */

/* TEventIterTree */

/* TOutputListSelectorDataMap */

/* TVirtualPacketizer */

/* TPacketizerAdaptive */

/* TPacketizerFile */

/* TPacketizer */

/* TPacketizerMulti */

/* TPacketizerUnit */

/* TPerfEvent */

/* TPerfStats */

/* TProofMonSender */

/* TProofLimitsFinder */

/* TProofMonSenderML */

/* TProofMonSenderSQL */

/* TProofPlayerLite */

/* TProofPlayerRemote */

/* TStatus */

/* TProofPlayer */

/* TProofPlayerLocal */

/* TProofPlayerSlave */

/* TProofPlayerSuperMaster */

/* TStatsFeedback */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__ProofPlayer {
 public:
  G__Sizep2memfuncG__ProofPlayer(): p(&G__Sizep2memfuncG__ProofPlayer::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__ProofPlayer::*p)();
};

size_t G__get_sizep2memfuncG__ProofPlayer()
{
  G__Sizep2memfuncG__ProofPlayer 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__ProofPlayer() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback))) {
     TDrawFeedback *G__Lderived;
     G__Lderived=(TDrawFeedback*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter))) {
     TEventIter *G__Lderived;
     G__Lderived=(TEventIter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit))) {
     TEventIterUnit *G__Lderived;
     G__Lderived=(TEventIterUnit*)0x1000;
     {
       TEventIter *G__Lpbase=(TEventIter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj))) {
     TEventIterObj *G__Lderived;
     G__Lderived=(TEventIterObj*)0x1000;
     {
       TEventIter *G__Lpbase=(TEventIter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj),G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree))) {
     TEventIterTree *G__Lderived;
     G__Lderived=(TEventIterTree*)0x1000;
     {
       TEventIter *G__Lpbase=(TEventIter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree),G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap))) {
     TOutputListSelectorDataMap *G__Lderived;
     G__Lderived=(TOutputListSelectorDataMap*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer))) {
     TVirtualPacketizer *G__Lderived;
     G__Lderived=(TVirtualPacketizer*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive))) {
     TPacketizerAdaptive *G__Lderived;
     G__Lderived=(TPacketizerAdaptive*)0x1000;
     {
       TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile))) {
     TPacketizerFile *G__Lderived;
     G__Lderived=(TPacketizerFile*)0x1000;
     {
       TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer))) {
     TPacketizer *G__Lderived;
     G__Lderived=(TPacketizer*)0x1000;
     {
       TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti))) {
     TPacketizerMulti *G__Lderived;
     G__Lderived=(TPacketizerMulti*)0x1000;
     {
       TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit))) {
     TPacketizerUnit *G__Lderived;
     G__Lderived=(TPacketizerUnit*)0x1000;
     {
       TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent))) {
     TPerfEvent *G__Lderived;
     G__Lderived=(TPerfEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats))) {
     TPerfStats *G__Lderived;
     G__Lderived=(TPerfStats*)0x1000;
     {
       TVirtualPerfStats *G__Lpbase=(TVirtualPerfStats*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPerfStats),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender))) {
     TProofMonSender *G__Lderived;
     G__Lderived=(TProofMonSender*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender),G__get_linked_tagnum(&G__G__ProofPlayerLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder))) {
     TProofLimitsFinder *G__Lderived;
     G__Lderived=(TProofLimitsFinder*)0x1000;
     {
       THLimitsFinder *G__Lpbase=(THLimitsFinder*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder),G__get_linked_tagnum(&G__G__ProofPlayerLN_THLimitsFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML))) {
     TProofMonSenderML *G__Lderived;
     G__Lderived=(TProofMonSenderML*)0x1000;
     {
       TProofMonSender *G__Lpbase=(TProofMonSender*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML),G__get_linked_tagnum(&G__G__ProofPlayerLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL))) {
     TProofMonSenderSQL *G__Lderived;
     G__Lderived=(TProofMonSenderSQL*)0x1000;
     {
       TProofMonSender *G__Lpbase=(TProofMonSender*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL),G__get_linked_tagnum(&G__G__ProofPlayerLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite))) {
     TProofPlayerLite *G__Lderived;
     G__Lderived=(TProofPlayerLite*)0x1000;
     {
       TProofPlayerRemote *G__Lpbase=(TProofPlayerRemote*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote))) {
     TProofPlayerRemote *G__Lderived;
     G__Lderived=(TProofPlayerRemote*)0x1000;
     {
       TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus))) {
     TStatus *G__Lderived;
     G__Lderived=(TStatus*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus),G__get_linked_tagnum(&G__G__ProofPlayerLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer))) {
     TProofPlayer *G__Lderived;
     G__Lderived=(TProofPlayer*)0x1000;
     {
       TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal))) {
     TProofPlayerLocal *G__Lderived;
     G__Lderived=(TProofPlayerLocal*)0x1000;
     {
       TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave))) {
     TProofPlayerSlave *G__Lderived;
     G__Lderived=(TProofPlayerSlave*)0x1000;
     {
       TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster))) {
     TProofPlayerSuperMaster *G__Lderived;
     G__Lderived=(TProofPlayerSuperMaster*)0x1000;
     {
       TProofPlayerRemote *G__Lpbase=(TProofPlayerRemote*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatsFeedback))) {
     TStatsFeedback *G__Lderived;
     G__Lderived=(TStatsFeedback*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatsFeedback),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatsFeedback),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__ProofPlayer() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 8 bytes (long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_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__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_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__ProofPlayerLN_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__ProofPlayerLN_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__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TDrawFeedback */
static void G__setup_memvarTDrawFeedback(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback));
   { TDrawFeedback *p; p=(TDrawFeedback*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fName=",0,"Identfier for this object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAll=",0,"draw all or selected objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_THashList),-1,-1,4,"fNames=",0,"selected objects");
   G__memvar_setup((void*)0,67,0,0,-1,G__defined_typename("Option_t"),-1,2,"fOption=",0,"draw option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof),-1,-1,2,"fProof=",0,"handle to PROOF session");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEventIter */
static void G__setup_memvarTEventIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter));
   { TEventIter *p; p=(TEventIter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventItercLcLEIterType),-1,-2,1,G__FastAllocString(2048).Format("kData=%lldLL",(long long)TEventIter::kData).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSet),-1,-1,2,"fDSet=",0,"data set over which to iterate");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement),-1,-1,2,"fElem=",0,"Current Element");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fFilename=",0,"Name of the current file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFile),-1,-1,2,"fFile=",0,"Current file");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fOldBytesRead=",0,"last reported number of bytes read");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fPath=",0,"Path to current TDirectory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDirectory),-1,-1,2,"fDir=",0,"directory containing the objects or the TTree");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fElemFirst=",0,"first entry to process for this element");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fElemNum=",0,"number of entries to process for this element");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fElemCur=",0,"current entry for this element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSelector),-1,-1,2,"fSel=",0,"selector to be used");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFirst=",0,"first entry to process");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fNum=",0,"number of entries to process");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fCur=",0,"current entry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStop=",0,"termination of run requested");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventList),-1,-1,2,"fEventList=",0,"! eventList for processing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEventListPos=",0,"! current position in the eventList");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEntryList),-1,-1,2,"fEntryList=",0,"! entry list for processing");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryListPos=",0,"! current position in the entrylist");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fPackets=",0,"list of packets processed packets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEventIterUnit */
static void G__setup_memvarTEventIterUnit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
   { TEventIterUnit *p; p=(TEventIterUnit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNum=",0,(char*)NULL);
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEventIterObj */
static void G__setup_memvarTEventIterObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
   { TEventIterObj *p; p=(TEventIterObj*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fClassName=",0,"class name of objects to iterate over");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fKeys=",0,"list of keys");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TIter),-1,-1,4,"fNextKey=",0,"next key in directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),-1,-1,4,"fObj=",0,"object found");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEventIterTree */
static void G__setup_memvarTEventIterTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
   { TEventIterTree *p; p=(TEventIterTree*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fTreeName=",0,"name of the tree object to iterate over");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree),-1,-1,4,"fTree=",0,"tree we are iterating over");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTreeCache),-1,-1,4,"fTreeCache=",0,"instance of the tree cache for the tree");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTreeCacheIsLearning=",0,"Whether cache is in learning phase");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseTreeCache=",0,"Control usage of the tree cache");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fCacheSize=",0,"Cache size");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseParallelUnzip=",0,"Control usage of parallel unzip");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDontCacheFiles=",0,"Control OS caching of read files (Mac Os X only)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFileTrees=",0,"Files && Trees currently open");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TOutputListSelectorDataMap */
static void G__setup_memvarTOutputListSelectorDataMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap));
   { TOutputListSelectorDataMap *p; p=(TOutputListSelectorDataMap*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TCollection),-1,-1,4,"fMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualPacketizer */
static void G__setup_memvarTVirtualPacketizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer));
   { TVirtualPacketizer *p; p=(TVirtualPacketizer*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-2,2,"kEstOff=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-2,2,"kEstCurrent=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-2,2,"kEstAverage=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinPacketTime=",0,"minimum packet time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxPacketTime=",0,"maximum packet time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fConfigParams=",0,"List of configuration parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,2,"fSlaveStats=",0,"slave status, keyed by correspondig TSlave");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus),-1,-1,2,"fProgressStatus=",0,"pointer to status in the player.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fProgress=",0,"progress updates timer");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalEntries=",0,"total number of entries to be distributed;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFailedPackets=",0,"a list of packets that failed while processing");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTime),-1,-1,2,"fStartTime=",0,"time offset");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fInitTime=",0,"time before processing");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fProcTime=",0,"time since start of processing");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTimeUpdt=",0,"time between updates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TNtupleD),-1,-1,2,"fCircProg=",0,"Keeps circular info for \"instantenous\"");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fCircN=",0,"Circularity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TNtuple),-1,-1,2,"fProgressPerf=",0,"{Active workers, evt rate, MBs read} as a function of processing time");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fProcTimeLast=",0,"Time of the last measurement");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActWrksLast=",0,"Active workers at fProcTimeLast");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEvtRateLast=",0,"Evt rate at fProcTimeLast");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMBsReadLast=",0,"MBs read at fProcTimeLast");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEffSessLast=",0,"Number of effective sessions at fProcTimeLast");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAWLastFill=",0,"Whether to fill the last measurement");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fReportPeriod=",0,"Time between reports if nothing changes (estimated proc time / 100)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-1,2,"fUseEstOpt=",0,"Control usage of estimated values for the progress info");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValid=",0,"Constructed properly?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStop=",0,"Termination of Process() requested?");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fDataSet=",0,"Name of the dataset being processed (for dataset-driven runs)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsInitializing=%lldLL",(long long)TVirtualPacketizer::kIsInitializing).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsDone=%lldLL",(long long)TVirtualPacketizer::kIsDone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsTree=%lldLL",(long long)TVirtualPacketizer::kIsTree).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPacketizerAdaptive */
static void G__setup_memvarTPacketizerAdaptive(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive));
   { TPacketizerAdaptive *p; p=(TPacketizerAdaptive*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFileNodes=",0,"nodes with files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fUnAllocated=",0,"nodes with unallocated files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fActive=",0,"nodes with unfinished files");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxPerfIdx=",0,"maximum of our slaves' performance index");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPartitions=",0,"list of partitions on nodes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSortedList),-1,-1,4,"fFilesToProcess=",0,"Global list of files (TFileStat) to be processed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCachePacketSync=",0,"control synchronization of cache and packet sizes");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMaxEntriesRatio=",0,"max file entries to avg allowed ratio for cache-to-packet sync");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFractionOfRemoteFiles=",0,"fraction of TDSetElements that are on non-workers");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNEventsOnRemLoc=",0,"number of events in currently");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBaseLocalPreference=",0,"indicates how much more likely the nodes will be");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fForceLocal=",0,"if 1 - eliminate the remote processing");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fMaxSlaveCnt=",0,"maximum number of workers per filenode (Long_t to avoid");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPacketAsAFraction=",0,"used to calculate the packet size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStrategy=",0,"0 means the classic and 1 (default) - the adaptive strategy");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTryReassign=",0,"Controls attempts to reassign packets (0 == no reassignment)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPacketizerFile */
static void G__setup_memvarTPacketizerFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile));
   { TPacketizerFile *p; p=(TPacketizerFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fFiles=",0,"Files to be produced/processed per node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fNotAssigned=",0,"List of files not assigned to a specific node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fIters=",0,"Iterators on the file lists per node");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fAssigned=",0,"No.files processed or being processed.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fProcNotAssigned=",0,"Whether to process files not asdigned to a worker");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAddFileInfo=",0,"Whether to add the TFileInfo object in the packet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStopwatch),-1,-1,4,"fStopwatch=",0,"For measuring the start time of each packet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPacketizer */
static void G__setup_memvarTPacketizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer));
   { TPacketizer *p; p=(TPacketizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPackets=",0,"all processed packets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFileNodes=",0,"nodes with files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fUnAllocated=",0,"nodes with unallocated files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fActive=",0,"nodes with unfinished files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fSlaveStats=",0,"slave status, keyed by correspondig TSlave");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fPacketSize=",0,"global base packet size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxPerfIdx=",0,"maximum of our slaves' performance index");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fMaxSlaveCnt=",0,"maximum number of workers per filenode (Long_t to avoid");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPacketAsAFraction=",0,"used to calculate the packet size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPacketizerMulti */
static void G__setup_memvarTPacketizerMulti(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti));
   { TPacketizerMulti *p; p=(TPacketizerMulti*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPacketizers=",0,"Packetizers to be processed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TIter),-1,-1,4,"fPacketizersIter=",0,"Iterator on fPacketizers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),-1,-1,4,"fCurrent=",0,"Packetizer being currently processed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fAssignedPack=",0,"Map {worker,packetizer} of lat assignement");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPacketizerUnit */
static void G__setup_memvarTPacketizerUnit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit));
   { TPacketizerUnit *p; p=(TPacketizerUnit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPackets=",0,"All processed packets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fWrkStats=",0,"Worker status, keyed by correspondig TSlave");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fWrkExcluded=",0,"List of nodes excluded from distribution");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStopwatch),-1,-1,4,"fStopwatch=",0,"For measuring the start time of each packet");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fProcessing=",0,"Event being processed");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fAssigned=",0,"Entries processed or being processed.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCalibFrac=",0,"Size of the calibrating packet as fraction of Ntot/Nwrk");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNumPerWorker=",0,"Number of cycles per worker, if this option");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFixedNum=",0,"Whether we must assign a fixed number of cycles per worker");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fPacketSeq=",0,"Sequential number of the last packet assigned");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fInput=",0,"Input list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPerfEvent */
static void G__setup_memvarTPerfEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent));
   { TPerfEvent *p; p=(TPerfEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fEvtNode)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fEvtNode=",0,"node on which the event was generated");
   G__memvar_setup((void*)((long)(&p->fTimeStamp)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimeStamp),-1,-1,1,"fTimeStamp=",0,"time offset from start of run");
   G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType),-1,-1,1,"fType=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSlaveName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fSlaveName=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNodeName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fNodeName=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fFileName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fFileName=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fFileClass)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fFileClass=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSlave)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fSlave=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fEventsProcessed)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fEventsProcessed=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fBytesRead)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fBytesRead=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fLen)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fLen=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fLatency)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fLatency=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fProcTime)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fProcTime=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fCpuTime)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fCpuTime=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fIsStart)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fIsStart=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fIsOk)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fIsOk=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPerfStats */
static void G__setup_memvarTPerfStats(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats));
   { TPerfStats *p; p=(TPerfStats*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree),-1,-1,4,"fTrace=",0,"!TTree with trace events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimeStamp),-1,-1,4,"fTzero=",0,"!start time of this run");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent),-1,-1,4,"fPerfEvent=",0,"!TPerfEvent used to fill tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1D),-1,-1,4,"fPacketsHist=",0,"!histogram of packets processed per slave");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1I),-1,-1,4,"fProcPcktHist=",0,"!histogram of packets being processed per slave");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1D),-1,-1,4,"fEventsHist=",0,"!histogram of events processed per slave");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1D),-1,-1,4,"fNodeHist=",0,"!histogram of slaves per file serving node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH2D),-1,-1,4,"fLatencyHist=",0,"!histogram of latency due to packet requests");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH2D),-1,-1,4,"fProcTimeHist=",0,"!histogram of real time spent processing packets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH2D),-1,-1,4,"fCpuTimeHist=",0,"!histogram of cpu time spent processing packets");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesRead=",0,"!track bytes read of main file");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTotCpuTime=",0,"!total cpu time of all slaves");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fTotBytesRead=",0,"!total bytes read on all slaves");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fTotEvents=",0,"!total number of events processed");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNumEvents=",0,"!total number of events to be processed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSlaves=",0,"!number of active slaves");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoHist=",0,"!Fill histos");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoTrace=",0,"!Trace details in master");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoTraceRate=",0,"!Trace processing rate in master");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoSlaveTrace=",0,"!Full tracing in workers");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoQuota=",0,"!Save stats on SQL server for quota management");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMonitorPerPacket=",0,"!Whether to send the full entry per each packet ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TObjArray),-1,-1,4,"fMonSenders=",0,"!Monitoring engines");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fDataSet=",0,"!Dataset string");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDataSetLen=",0,"!Maximum size of the dataset string fDataSet ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDataSetSize=",0,"!# of files in the dataset ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSet),-1,-1,4,"fDSet=",0,"!Saved pointer to the TDSet object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fOutput=",0,"!Saved pointer to the output list ");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgVirtMemMax=",0,"! Max virtual memory used by this process");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgResMemMax=",0,"! Max resident memory used by this process");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofMonSender */
static void G__setup_memvarTProofMonSender(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender));
   { TProofMonSender *p; p=(TProofMonSender*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSummaryVrs=",0,"Version of the summary 'table'");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDataSetInfoVrs=",0,"Version of the dataset info 'table'");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFileInfoVrs=",0,"Version of the file info 'table'");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSendercLcLEConfigBits),-1,-2,2,"kSendSummary=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSendercLcLEConfigBits),-1,-2,2,"kSendDataSetInfo=65536LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSendercLcLEConfigBits),-1,-2,2,"kSendFileInfo=131072LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofLimitsFinder */
static void G__setup_memvarTProofLimitsFinder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder));
   { TProofLimitsFinder *p; p=(TProofLimitsFinder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofMonSenderML */
static void G__setup_memvarTProofMonSenderML(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML));
   { TProofMonSenderML *p; p=(TProofMonSenderML*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualMonitoringWriter),-1,-1,4,"fWriter=",0,"Writer instance connect to backend");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofMonSenderSQL */
static void G__setup_memvarTProofMonSenderSQL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL));
   { TProofMonSenderSQL *p; p=(TProofMonSenderSQL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualMonitoringWriter),-1,-1,4,"fWriter=",0,"Writer instance connect to backend");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fDSetSendOpts=",0,"Opts for posting dataset table");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fFilesSendOpts=",0,"Opts for posting files table");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofPlayerLite */
static void G__setup_memvarTProofPlayerLite(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite));
   { TProofPlayerLite *p; p=(TProofPlayerLite*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofPlayerRemote */
static void G__setup_memvarTProofPlayerRemote(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote));
   { TProofPlayerRemote *p; p=(TProofPlayerRemote*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof),-1,-1,2,"fProof=",0,"link to associated PROOF session");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fOutputLists=",0,"results returned by slaves");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFeedback=",0,"reference for use on master");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFeedbackLists=",0,"intermediate results");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),-1,-1,2,"fPacketizer=",0,"transform TDSet into packets for slaves");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMergeFiles=",0,"is True when merging output files centrally is needed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSet),-1,-1,2,"fDSet=",0,"!tdset for current processing");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ErrorHandlerFunc_t"),-1,2,"fErrorHandler=",0,"Store previous handler when redirecting output");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMergeTH1OneByOne=",0,"If kTRUE forces TH1 merge one-by-one [kTRUE]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1),-1,-1,2,"fProcPackets=",0,"!Histogram with packets being processed (owned by TPerfStats)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMessage),-1,-1,2,"fProcessMessage=",0,"Process message to replay when adding new workers dynamically");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fSelectorFileName=",0,"Current Selector's name, set by Process()");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStatus */
static void G__setup_memvarTStatus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
   { TStatus *p; p=(TStatus*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatuscLcLEProcStatus),-1,-2,1,G__FastAllocString(2048).Format("kNotOk=%lldLL",(long long)TStatus::kNotOk).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fMsgs=",0,"list of error messages");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TIter),-1,-1,4,"fIter=",0,"!iterator in messages");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_THashList),-1,-1,4,"fInfoMsgs=",0,"list of info messages");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fExitStatus=",0,"Query exit status ((Int_t)TVirtualProofPlayer::EExitStatus or -1);");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fVirtMemMax=",0,"Max virtual memory used by the worker");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fResMemMax=",0,"Max resident memory used by the worker");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fVirtMaxMst=",0,"Max virtual memory used by the master");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fResMaxMst=",0,"Max resident memory used by the master");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofPlayer */
static void G__setup_memvarTProofPlayer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer));
   { TProofPlayer *p; p=(TProofPlayer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fAutoBins=",0,"Map of min/max values by name for slaves");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fInput=",0,"-> list with input objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_THashList),-1,-1,2,"fOutput=",0,"list with output objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSelector),-1,-1,2,"fSelector=",0,"!  the latest selector");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCreateSelObj=",0,"!  kTRUE when fSelector has been created locally");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-1,2,"fSelectorClass=",0,"!  class of the latest selector");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fFeedbackTimer=",0,"!  timer for sending intermediate results");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fFeedbackPeriod=",0,"!  period (ms) for sending intermediate results");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),-1,-1,2,"fEvIter=",0,"!  iterator on events or objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus),-1,-1,2,"fSelStatus=",0,"!  status of query in progress");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus),-1,-1,2,"fExitStatus=",0,"exit status");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalEvents=",0,"number of events requested");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus),-1,-1,2,"fProgressStatus=",0,"the progress status object;");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fReadBytesRun=",0,"! Bytes read in this run");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fReadCallsRun=",0,"! Read calls in this run");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fProcessedRun=",0,"! Events processed in this run");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fQueryResults=",0,"List of TQueryResult");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult),-1,-1,2,"fQuery=",0,"Instance of TQueryResult currently processed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult),-1,-1,2,"fPreviousQuery=",0,"Previous instance of TQueryResult processed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDrawQueries=",0,"Number of Draw queries in the list");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxDrawQueries=",0,"Max number of Draw queries kept");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fStopTimer=",0,"Timer associated with a stop request");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMutex),-1,-1,2,"fStopTimerMtx=",0,"To protect the stop timer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fDispatchTimer=",0,"Dispatch pending events while processing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fProcTimeTimer=",0,"Notifies reaching of allowed max proc time ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStopwatch),-1,-1,2,"fProcTime=",0,"Packet proc time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fOutputFilePath=",0,"Path to file with (partial) results of the query");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFile),-1,-1,2,"fOutputFile=",0,"TFile object attached to fOutputFilePath");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fSaveMemThreshold=",0,"Threshold for saving output to file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSavePartialResults=",0,"Whether to save the partial results");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSaveResultsPerPacket=",0,"Whether to save partial results after each packet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_THashList),-1,-2,2,"fgDrawInputPars=",0,"List of input parameters to be kept on drawing actions");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kDispatchOneEvent=%lldLL",(long long)TProofPlayer::kDispatchOneEvent).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsProcessing=%lldLL",(long long)TProofPlayer::kIsProcessing).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kMaxProcTimeReached=%lldLL",(long long)TProofPlayer::kMaxProcTimeReached).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kMaxProcTimeExtended=%lldLL",(long long)TProofPlayer::kMaxProcTimeExtended).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofPlayerLocal */
static void G__setup_memvarTProofPlayerLocal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal));
   { TProofPlayerLocal *p; p=(TProofPlayerLocal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsClient=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofPlayerSlave */
static void G__setup_memvarTProofPlayerSlave(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave));
   { TProofPlayerSlave *p; p=(TProofPlayerSlave*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSocket),-1,-1,4,"fSocket=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFeedback=",0,"List of objects to send updates of");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofPlayerSuperMaster */
static void G__setup_memvarTProofPlayerSuperMaster(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster));
   { TProofPlayerSuperMaster *p; p=(TProofPlayerSuperMaster*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayL64),-1,-1,4,"fSlaveProgress=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayL64),-1,-1,4,"fSlaveTotals=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayL64),-1,-1,4,"fSlaveBytesRead=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveInitTime=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveProcTime=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveEvtRti=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveMBRti=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayI),-1,-1,4,"fSlaveActW=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayI),-1,-1,4,"fSlaveTotS=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveEffS=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fSlaves=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReturnFeedback=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStatsFeedback */
static void G__setup_memvarTStatsFeedback(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatsFeedback));
   { TStatsFeedback *p; p=(TStatsFeedback*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fName=",0,"Identfier for this object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof),-1,-1,2,"fProof=",0,"handle to PROOF session");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__ProofPlayer() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTDrawFeedback(void) {
   /* TDrawFeedback */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback));
   G__memfunc_setup("TDrawFeedback",1255,G__G__ProofPlayer_128_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback), -1, 0, 2, 1, 1, 0, 
"U 'TProof' - 0 '0' proof U 'TSeqCollection' - 0 '0' names", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Feedback",773,G__G__ProofPlayer_128_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__ProofPlayer_128_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_128_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDrawFeedback::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_128_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDrawFeedback::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_128_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDrawFeedback::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_128_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDrawFeedback::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_128_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_128_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDrawFeedback::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_128_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDrawFeedback::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_128_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDrawFeedback::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_128_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDrawFeedback::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDrawFeedback", 1381, G__G__ProofPlayer_128_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEventIter(void) {
   /* TEventIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter));
   G__memfunc_setup("LoadDir",671,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", "Load the directory pointed to by fElem", (void*) NULL, 0);
   G__memfunc_setup("GetCacheSize",1167,G__G__ProofPlayer_138_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLearnEntries",1516,G__G__ProofPlayer_138_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNextEvent",1217,G__G__ProofPlayer_138_0_6, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNextPacket",1303,G__G__ProofPlayer_138_0_7, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"n - 'Long64_t' 1 - first n - 'Long64_t' 1 - num "
"U 'TEntryList' - 2 '0' enl U 'TEventList' - 2 '0' evl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InvalidatePacket",1625,G__G__ProofPlayer_138_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreProcessEvent",1544,G__G__ProofPlayer_138_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StopProcess",1157,G__G__ProofPlayer_138_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - abort", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPackets",1003,G__G__ProofPlayer_138_0_11, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Create",596,G__G__ProofPlayer_138_0_12, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter), -1, 0, 4, 3, 1, 0, 
"U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num", (char*)NULL, (void*) G__func2void( (TEventIter* (*)(TDSet*, TSelector*, Long64_t, Long64_t))(&TEventIter::Create) ), 0);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_138_0_13, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_138_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_138_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_138_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_138_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_138_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_138_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_138_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_138_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEventIter", 1128, G__G__ProofPlayer_138_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofPlayer_138_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter), -1, 1, 1, 1, 1, 0, "u 'TEventIter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEventIterUnit(void) {
   /* TEventIterUnit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
   G__memfunc_setup("TEventIterUnit",1418,G__G__ProofPlayer_140_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEventIterUnit",1418,G__G__ProofPlayer_140_0_2, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 0, 3, 1, 1, 0, 
"U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
"n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextEvent",1217,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"n - 'Long64_t' 1 - first n - 'Long64_t' 1 - num "
"U 'TEntryList' - 2 '0' enl U 'TEventList' - 2 '0' evl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreProcessEvent",1544,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_140_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIterUnit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_140_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterUnit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_140_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIterUnit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_140_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIterUnit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_140_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_140_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterUnit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_140_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterUnit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_140_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterUnit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_140_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterUnit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEventIterUnit", 1418, G__G__ProofPlayer_140_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 0, 1, 1, 1, 0, "u 'TEventIterUnit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEventIterUnit", 1544, G__G__ProofPlayer_140_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofPlayer_140_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 1, 1, 1, 1, 0, "u 'TEventIterUnit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEventIterObj(void) {
   /* TEventIterObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
   G__memfunc_setup("TEventIterObj",1285,G__G__ProofPlayer_141_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEventIterObj",1285,G__G__ProofPlayer_141_0_2, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextEvent",1217,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"n - 'Long64_t' 1 - first n - 'Long64_t' 1 - num "
"U 'TEntryList' - 2 '0' enl U 'TEventList' - 2 '0' evl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreProcessEvent",1544,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_141_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIterObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_141_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_141_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIterObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_141_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIterObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_141_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_141_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_141_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_141_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_141_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterObj::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEventIterObj", 1285, G__G__ProofPlayer_141_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 0, 1, 1, 1, 0, "u 'TEventIterObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEventIterObj", 1411, G__G__ProofPlayer_141_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofPlayer_141_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 1, 1, 1, 1, 0, "u 'TEventIterObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEventIterTree(void) {
   /* TEventIterTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
   G__memfunc_setup("Load",384,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree), -1, 0, 2, 1, 4, 0, 
"U 'TDSetElement' - 0 - elem g - 'Bool_t' 1 - localfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrees",803,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree), -1, 0, 1, 1, 4, 0, "U 'TDSetElement' - 0 - elem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEventIterTree",1402,G__G__ProofPlayer_142_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEventIterTree",1402,G__G__ProofPlayer_142_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextEvent",1217,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"n - 'Long64_t' 1 - first n - 'Long64_t' 1 - num "
"U 'TEntryList' - 2 '0' enl U 'TEventList' - 2 '0' evl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreProcessEvent",1544,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_142_0_10, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIterTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_142_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_142_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIterTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_142_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIterTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_142_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_142_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_142_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_142_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_142_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterTree::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEventIterTree", 1402, G__G__ProofPlayer_142_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 0, 1, 1, 1, 0, "u 'TEventIterTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEventIterTree", 1528, G__G__ProofPlayer_142_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofPlayer_142_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 1, 1, 1, 1, 0, "u 'TEventIterTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTOutputListSelectorDataMap(void) {
   /* TOutputListSelectorDataMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap));
   G__memfunc_setup("TOutputListSelectorDataMap",2650,G__G__ProofPlayer_144_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 0, 1, 1, 1, 0, "U 'TSelector' - 0 '0' sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindInList",980,G__G__ProofPlayer_144_0_2, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 0, 1, 3, 1, 0, "U 'TCollection' - 0 - coll", (char*)NULL, (void*) G__func2void( (TOutputListSelectorDataMap* (*)(TCollection*))(&TOutputListSelectorDataMap::FindInList) ), 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,G__G__ProofPlayer_144_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TSelector' - 0 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataMembers",1393,G__G__ProofPlayer_144_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TSelector' - 0 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__ProofPlayer_144_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMap",574,G__G__ProofPlayer_144_0_7, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_144_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TOutputListSelectorDataMap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_144_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOutputListSelectorDataMap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_144_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TOutputListSelectorDataMap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_144_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TOutputListSelectorDataMap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_144_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_144_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOutputListSelectorDataMap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_144_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOutputListSelectorDataMap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_144_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOutputListSelectorDataMap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_144_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOutputListSelectorDataMap::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TOutputListSelectorDataMap", 2650, G__G__ProofPlayer_144_0_20, (int) ('i'), 
G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 0, 1, 1, 1, 0, "u 'TOutputListSelectorDataMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TOutputListSelectorDataMap", 2776, G__G__ProofPlayer_144_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofPlayer_144_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 1, 1, 1, 1, 0, "u 'TOutputListSelectorDataMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualPacketizer(void) {
   /* TVirtualPacketizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer));
   G__memfunc_setup("TVirtualPacketizer",1869,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 2, 1, 2, 0, 
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 '0' st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVirtualPacketizer",1869,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 1, 1, 2, 0, "u 'TVirtualPacketizer' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TVirtualPacketizer' - 11 - -", "error on accidental usage", (void*) NULL, 0);
   G__memfunc_setup("CreateNewPacket",1494,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 3, 1, 2, 0, 
"U 'TDSetElement' - 0 - base n - 'Long64_t' 0 - first "
"n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 2, 0, 
"g - 'Bool_t' 0 - tree U 'TDSetElement' - 0 - e", "Num of entries or objects", (void*) NULL, 0);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,G__G__ProofPlayer_163_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntriesProcessed",1954,G__G__ProofPlayer_163_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEstEntriesProcessed",2254,G__G__ProofPlayer_163_0_9, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - - n - 'Long64_t' 1 - ent "
"n - 'Long64_t' 1 - bytes n - 'Long64_t' 1 - calls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentRate",1423,G__G__ProofPlayer_163_0_10, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTotalEntries",1534,G__G__ProofPlayer_163_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPacket",1303,G__G__ProofPlayer_163_0_12, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInitTime",1103,G__G__ProofPlayer_163_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopProcess",1157,G__G__ProofPlayer_163_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - abort g - 'Bool_t' 0 'kFALSE' stoptimer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFailedPackets",1584,G__G__ProofPlayer_163_0_15, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFailedPackets",1596,G__G__ProofPlayer_163_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWorkers",1014,G__G__ProofPlayer_163_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TList' - 0 - workers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBytesRead",1187,G__G__ProofPlayer_163_0_18, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadCalls",1163,G__G__ProofPlayer_163_0_19, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCumProcTime",1384,G__G__ProofPlayer_163_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInitTime",1091,G__G__ProofPlayer_163_0_21, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProcTime",1091,G__G__ProofPlayer_163_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProgressPerf",1538,G__G__ProofPlayer_163_0_23, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TNtuple), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' steal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfigParams",1498,G__G__ProofPlayer_163_0_24, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' steal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarkBad",658,G__G__ProofPlayer_163_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSlave' - 0 - - U 'TProofProgressStatus' - 0 - - "
"U 'TList' - 2 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddProcessed",1201,G__G__ProofPlayer_163_0_26, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TSlave' - 0 - - U 'TProofProgressStatus' - 0 - - "
"d - 'Double_t' 0 - - U 'TList' - 2 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStatus",932,G__G__ProofPlayer_163_0_27, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProgressStatus",1797,G__G__ProofPlayer_163_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTotalEntries",1546,G__G__ProofPlayer_163_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlaveStats",1322,G__G__ProofPlayer_163_0_30, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActiveWorkers",1641,G__G__ProofPlayer_163_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_163_0_32, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualPacketizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_163_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPacketizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_163_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualPacketizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_163_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPacketizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_163_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_163_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPacketizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_163_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPacketizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_163_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPacketizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_163_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPacketizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualPacketizer", 1995, G__G__ProofPlayer_163_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPacketizerAdaptive(void) {
   /* TPacketizerAdaptive */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive));
   G__memfunc_setup("TPacketizerAdaptive",1940,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizerAdaptive",1940,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive), -1, 0, 1, 1, 4, 0, "u 'TPacketizerAdaptive' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
   G__memfunc_setup("InitStats",931,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "initialise the stats", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerAdaptive' - 11 - -", "error on accidental usage", (void*) NULL, 0);
   G__memfunc_setup("NextNode",805,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveUnAllocNode",1698,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizerAdaptive::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextActiveNode",1409,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveActiveNode",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizerAdaptive::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextUnAlloc",1389,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat), -1, 0, 2, 1, 4, 0, 
"U 'TPacketizerAdaptive::TFileNode' - 0 '0' node C - - 10 '0' nodeHostName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextActive",1307,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveActive",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizerAdaptive::TFileStat' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidateFiles",1309,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
"n - 'Long64_t' 0 '-1' maxent g - 'Bool_t' 0 'kFALSE' byfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReassignPacket",1428,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"U 'TDSetElement' - 0 - e U 'TList' - 2 - listOfMissingFiles", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitPerHost",1233,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TList' - 0 - elements U 'TList' - 2 - listOfMissingFiles", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizerAdaptive",1940,G__G__ProofPlayer_172_0_16, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive), -1, 0, 6, 1, 1, 0, 
"U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddProcessed",1201,G__G__ProofPlayer_172_0_17, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TSlave' - 0 - sl U 'TProofProgressStatus' - 0 - st "
"d - 'Double_t' 0 - latency U 'TList' - 2 '0' listOfMissingFiles", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEstEntriesProcessed",2254,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - - n - 'Long64_t' 1 - ent "
"n - 'Long64_t' 1 - bytes n - 'Long64_t' 1 - calls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculatePacketSize",1921,G__G__ProofPlayer_172_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - slstat n - 'Long64_t' 0 - cachesz "
"i - 'Int_t' 0 - learnent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MarkBad",658,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSlave' - 0 - s U 'TProofProgressStatus' - 0 - status "
"U 'TList' - 2 - missingFiles", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_172_0_24, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerAdaptive::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_172_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerAdaptive::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_172_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerAdaptive::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_172_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerAdaptive::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_172_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_172_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerAdaptive::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_172_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerAdaptive::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_172_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerAdaptive::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_172_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerAdaptive::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPacketizerAdaptive", 2066, G__G__ProofPlayer_172_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPacketizerFile(void) {
   /* TPacketizerFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile));
   G__memfunc_setup("TPacketizerFile",1510,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizerFile",1510,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile), -1, 0, 1, 1, 4, 0, "u 'TPacketizerFile' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerFile' - 11 - -", "error on accidental usage", (void*) NULL, 0);
   G__memfunc_setup("TPacketizerFile",1510,G__G__ProofPlayer_187_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile), -1, 0, 4, 1, 1, 0, 
"U 'TList' - 0 - workers n - 'Long64_t' 0 - - "
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 '0' st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - wrk U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentTime",1426,G__G__ProofPlayer_187_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_187_0_9, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_187_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_187_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_187_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_187_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_187_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_187_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_187_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_187_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerFile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPacketizerFile", 1636, G__G__ProofPlayer_187_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPacketizer(void) {
   /* TPacketizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer));
   G__memfunc_setup("TPacketizer",1126,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizer",1126,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer), -1, 0, 1, 1, 4, 0, "u 'TPacketizer' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizer' - 11 - -", "error on accidental usage", (void*) NULL, 0);
   G__memfunc_setup("NextUnAllocNode",1491,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveUnAllocNode",1698,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextActiveNode",1409,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveActiveNode",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextUnAlloc",1389,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileStat), -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileNode' - 0 '0' node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextActive",1307,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileStat), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveActive",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileStat' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidateFiles",1309,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
"n - 'Long64_t' 0 '-1' maxent g - 'Bool_t' 0 'kFALSE' byfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizer",1126,G__G__ProofPlayer_190_0_13, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer), -1, 0, 6, 1, 1, 0, 
"U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesProcessed",1954,G__G__ProofPlayer_190_0_15, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "U 'TSlave' - 0 - sl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_190_0_18, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_190_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_190_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_190_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_190_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_190_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_190_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_190_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_190_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPacketizer", 1252, G__G__ProofPlayer_190_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPacketizerMulti(void) {
   /* TPacketizerMulti */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti));
   G__memfunc_setup("TPacketizerMulti",1649,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizerMulti",1649,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti), -1, 0, 1, 1, 4, 0, "u 'TPacketizerMulti' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerMulti' - 11 - -", "error on accidental usage", (void*) NULL, 0);
   G__memfunc_setup("CreatePacketizer",1638,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 6, 1, 4, 0, 
"U 'TDSet' - 0 - dset U 'TList' - 0 - wrks "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizerMulti",1649,G__G__ProofPlayer_194_0_5, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti), -1, 0, 6, 1, 1, 0, 
"U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - wrk U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEstEntriesProcessed",2254,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - f n - 'Long64_t' 1 - ent "
"n - 'Long64_t' 1 - bytes n - 'Long64_t' 1 - calls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - abort g - 'Bool_t' 0 'kFALSE' stoptimer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MarkBad",658,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSlave' - 0 - wrk U 'TProofProgressStatus' - 0 - st "
"U 'TList' - 2 - missing", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddProcessed",1201,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TSlave' - 0 - wrk U 'TProofProgressStatus' - 0 - st "
"d - 'Double_t' 0 - lat U 'TList' - 2 - missing", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_194_0_13, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerMulti::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_194_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerMulti::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_194_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerMulti::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_194_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerMulti::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_194_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_194_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerMulti::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_194_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerMulti::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_194_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerMulti::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_194_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerMulti::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPacketizerMulti", 1775, G__G__ProofPlayer_194_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPacketizerUnit(void) {
   /* TPacketizerUnit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit));
   G__memfunc_setup("TPacketizerUnit",1542,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPacketizerUnit",1542,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit), -1, 0, 1, 1, 4, 0, "u 'TPacketizerUnit' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerUnit' - 11 - -", "error on accidental usage", (void*) NULL, 0);
   G__memfunc_setup("TPacketizerUnit",1542,G__G__ProofPlayer_195_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit), -1, 0, 4, 1, 1, 0, 
"U 'TList' - 0 - slaves n - 'Long64_t' 0 - num "
"U 'TList' - 0 - input U 'TProofProgressStatus' - 0 '0' st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssignWork",1032,G__G__ProofPlayer_195_0_5, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TDSet' - 0 - - n - 'Long64_t' 0 - - "
"n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentTime",1426,G__G__ProofPlayer_195_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWorkers",1014,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TList' - 0 - workers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_195_0_11, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerUnit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_195_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerUnit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_195_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerUnit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_195_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerUnit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_195_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_195_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerUnit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_195_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerUnit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_195_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerUnit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_195_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerUnit::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPacketizerUnit", 1668, G__G__ProofPlayer_195_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPerfEvent(void) {
   /* TPerfEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent));
   G__memfunc_setup("TPerfEvent",995,G__G__ProofPlayer_209_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent), -1, 0, 1, 1, 1, 0, "U 'TTimeStamp' - 0 '0' offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_209_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPerfEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_209_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_209_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPerfEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_209_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_209_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_209_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_209_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_209_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_209_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPerfEvent", 995, G__G__ProofPlayer_209_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent), -1, 0, 1, 1, 1, 0, "u 'TPerfEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPerfEvent", 1121, G__G__ProofPlayer_209_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__ProofPlayer_209_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent), -1, 1, 1, 1, 1, 0, "u 'TPerfEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPerfStats(void) {
   /* TPerfStats */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats));
   G__memfunc_setup("TPerfStats",1008,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats), -1, 0, 2, 1, 4, 0, 
"U 'TList' - 0 - input U 'TList' - 0 - output", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteQueryLog",1347,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimpleEvent",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i 'TVirtualPerfStats::EEventType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PacketEvent",1114,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
"C - - 10 - slave C - - 10 - slavename "
"C - - 10 - filename n - 'Long64_t' 0 - eventsprocessed "
"d - 'Double_t' 0 - latency d - 'Double_t' 0 - proctime "
"d - 'Double_t' 0 - cputime n - 'Long64_t' 0 - bytesRead", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FileEvent",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - slave C - - 10 - slavename "
"C - - 10 - nodename C - - 10 - filename "
"g - 'Bool_t' 0 - isStart", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FileOpenEvent",1300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TFile' - 0 - file C - - 10 - filename "
"d - 'Double_t' 0 - start", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FileReadEvent",1278,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TFile' - 0 - file i - 'Int_t' 0 - len "
"d - 'Double_t' 0 - start", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FileUnzipEvent",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TFile' - 0 - file n - 'Long64_t' 0 - pos "
"d - 'Double_t' 0 - start i - 'Int_t' 0 - complen "
"i - 'Int_t' 0 - objlen", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RateEvent",910,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - proctime d - 'Double_t' 0 - deltatime "
"n - 'Long64_t' 0 - eventsprocessed n - 'Long64_t' 0 - bytesRead", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBytesRead",1199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBytesRead",1187,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumEvents",1233,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumEvents",1221,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Start",526,G__G__ProofPlayer_210_0_14, 121, -1, -1, 0, 2, 3, 1, 0, 
"U 'TList' - 0 - input U 'TList' - 0 - output", (char*)NULL, (void*) G__func2void( (void (*)(TList*, TList*))(&TPerfStats::Start) ), 0);
   G__memfunc_setup("Stop",422,G__G__ProofPlayer_210_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfStats::Stop) ), 0);
   G__memfunc_setup("Setup",529,G__G__ProofPlayer_210_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TList' - 0 - input", (char*)NULL, (void*) G__func2void( (void (*)(TList*))(&TPerfStats::Setup) ), 0);
   G__memfunc_setup("SetMemValues",1211,G__G__ProofPlayer_210_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfStats::SetMemValues) ), 0);
   G__memfunc_setup("GetMemValues",1199,G__G__ProofPlayer_210_0_18, 121, -1, -1, 0, 2, 3, 1, 0, 
"l - 'Long_t' 1 - vmax l - 'Long_t' 1 - rmax", (char*)NULL, (void*) G__func2void( (void (*)(Long_t&, Long_t&))(&TPerfStats::GetMemValues) ), 0);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_210_0_19, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPerfStats::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_210_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfStats::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_210_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPerfStats::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_210_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfStats::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_210_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_210_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfStats::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_210_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfStats::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_210_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfStats::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_210_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfStats::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPerfStats", 1134, G__G__ProofPlayer_210_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofMonSender(void) {
   /* TProofMonSender */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender));
   G__memfunc_setup("SetSendOptions",1442,G__G__ProofPlayer_211_0_2, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__ProofPlayer_211_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendSummary",1144,G__G__ProofPlayer_211_0_4, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TList' - 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SendDataSetInfo",1468,G__G__ProofPlayer_211_0_5, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - - U 'TList' - 0 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SendFileInfo",1174,G__G__ProofPlayer_211_0_6, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - - U 'TList' - 0 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_211_0_7, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofMonSender::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_211_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSender::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_211_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofMonSender::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_211_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofMonSender::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_211_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_211_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSender::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_211_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMonSender::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_211_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSender::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_211_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMonSender::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofMonSender", 1635, G__G__ProofPlayer_211_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__ProofPlayer_211_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSender), -1, 1, 1, 1, 1, 0, "u 'TProofMonSender' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofLimitsFinder(void) {
   /* TProofLimitsFinder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder));
   G__memfunc_setup("TProofLimitsFinder",1828,G__G__ProofPlayer_214_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindGoodLimits",1404,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - h d - 'Axis_t' 0 - xmin "
"d - 'Axis_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindGoodLimits",1404,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"U 'TH1' - 0 - h d - 'Axis_t' 0 - xmin "
"d - 'Axis_t' 0 - xmax d - 'Axis_t' 0 - ymin "
"d - 'Axis_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindGoodLimits",1404,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 7, 1, 1, 0, 
"U 'TH1' - 0 - h d - 'Axis_t' 0 - xmin "
"d - 'Axis_t' 0 - xmax d - 'Axis_t' 0 - ymin "
"d - 'Axis_t' 0 - ymax d - 'Axis_t' 0 - zmin "
"d - 'Axis_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AutoBinFunc",1086,G__G__ProofPlayer_214_0_5, 121, -1, -1, 0, 7, 3, 1, 0, 
"u 'TString' - 1 - key d - 'Double_t' 1 - xmin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmin "
"d - 'Double_t' 1 - zmax", (char*)NULL, (void*) G__func2void( (void (*)(TString&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&))(&TProofLimitsFinder::AutoBinFunc) ), 0);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_214_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofLimitsFinder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_214_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLimitsFinder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_214_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofLimitsFinder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_214_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofLimitsFinder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_214_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_214_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLimitsFinder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_214_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLimitsFinder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_214_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLimitsFinder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_214_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLimitsFinder::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofLimitsFinder", 1828, G__G__ProofPlayer_214_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder), -1, 0, 1, 1, 1, 0, "u 'TProofLimitsFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofLimitsFinder", 1954, G__G__ProofPlayer_214_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__ProofPlayer_214_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder), -1, 1, 1, 1, 1, 0, "u 'TProofLimitsFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofMonSenderML(void) {
   /* TProofMonSenderML */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML));
   G__memfunc_setup("TProofMonSenderML",1662,G__G__ProofPlayer_219_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML), -1, 0, 5, 1, 1, 0, 
"C - - 10 - serv C - - 10 - tag "
"C - - 10 '0' id C - - 10 '0' subid "
"C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendSummary",1144,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TList' - 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendDataSetInfo",1468,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - - U 'TList' - 0 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendFileInfo",1174,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - - U 'TList' - 0 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_219_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofMonSenderML::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_219_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSenderML::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_219_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofMonSenderML::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_219_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofMonSenderML::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_219_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_219_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSenderML::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_219_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMonSenderML::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_219_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSenderML::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_219_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMonSenderML::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofMonSenderML", 1662, G__G__ProofPlayer_219_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML), -1, 0, 1, 1, 1, 0, "u 'TProofMonSenderML' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofMonSenderML", 1788, G__G__ProofPlayer_219_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__ProofPlayer_219_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderML), -1, 1, 1, 1, 1, 0, "u 'TProofMonSenderML' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofMonSenderSQL(void) {
   /* TProofMonSenderSQL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL));
   G__memfunc_setup("TProofMonSenderSQL",1749,G__G__ProofPlayer_220_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL), -1, 0, 6, 1, 1, 0, 
"C - - 10 - serv C - - 10 - user "
"C - - 10 - pass C - - 10 '\"proof.proofquerylog\"' table "
"C - - 10 '0' dstab C - - 10 '0' filestab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendSummary",1144,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TList' - 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendDataSetInfo",1468,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - - U 'TList' - 0 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendFileInfo",1174,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TDSet' - 0 - - U 'TList' - 0 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_220_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofMonSenderSQL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_220_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSenderSQL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_220_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofMonSenderSQL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_220_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofMonSenderSQL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_220_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_220_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSenderSQL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_220_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMonSenderSQL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_220_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMonSenderSQL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_220_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMonSenderSQL::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofMonSenderSQL", 1749, G__G__ProofPlayer_220_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL), -1, 0, 1, 1, 1, 0, "u 'TProofMonSenderSQL' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofMonSenderSQL", 1875, G__G__ProofPlayer_220_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__ProofPlayer_220_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofMonSenderSQL), -1, 1, 1, 1, 1, 0, "u 'TProofMonSenderSQL' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofPlayerLite(void) {
   /* TProofPlayerLite */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite));
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeSelector",1215,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - - 10 - selfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProofPlayerLite",1621,G__G__ProofPlayer_276_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set U 'TSelector' - 0 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StoreFeedback",1298,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_276_0_10, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerLite::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_276_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLite::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_276_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerLite::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_276_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerLite::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_276_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_276_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLite::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_276_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLite::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_276_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLite::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_276_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLite::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPlayerLite", 1747, G__G__ProofPlayer_276_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofPlayerRemote(void) {
   /* TProofPlayerRemote */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote));
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitPacketizer",1446,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"U 'TDSet' - 0 - dset n - 'Long64_t' 0 - nentries "
"n - 'Long64_t' 0 - first C - - 10 - defpackunit "
"C - - 10 - defpackdata", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MergeFeedback",1269,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MergeOutputFiles",1652,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NotifyMemory",1266,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastMergingMsg",1712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendSelector",1227,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - selector_file", "send selector to slaves", (void*) NULL, 1);
   G__memfunc_setup("GetProof",806,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "specialized setup", (void*) NULL, 1);
   G__memfunc_setup("StopFeedback",1195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "specialized teardown", (void*) NULL, 1);
   G__memfunc_setup("SetSelectorDataMembersFromOutputList",3699,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofPlayerRemote",1843,G__G__ProofPlayer_277_0_12, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set U 'TSelector' - 0 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("JoinProcess",1135,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TList' - 0 - workers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSelect",1006,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - varexp "
"C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RedirectOutput",1475,G__G__ProofPlayer_277_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - abort i - 'Int_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StoreOutput",1182,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
   G__memfunc_setup("StoreFeedback",1298,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
   G__memfunc_setup("Incorporate",1158,G__G__ProofPlayer_277_0_23, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj U 'TList' - 0 - out "
"g - 'Bool_t' 1 - merged", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleHistogram",1530,G__G__ProofPlayer_277_0_24, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 1 - merged", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HistoSameAxis",1314,G__G__ProofPlayer_277_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h0 U 'TH1' - 0 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOutputObject",1521,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOutput",922,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Incorporate a list", (void*) NULL, 1);
   G__memfunc_setup("MergeOutput",1153,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
"n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
"n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
"f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
"f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
"U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
"n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
"f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
"f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - - U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Feedback",773,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - slave U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPacketizer",1330,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsClient",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInitTime",1103,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_277_0_40, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerRemote::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_277_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerRemote::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_277_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerRemote::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_277_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerRemote::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_277_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_277_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerRemote::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_277_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerRemote::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_277_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerRemote::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_277_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerRemote::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPlayerRemote", 1969, G__G__ProofPlayer_277_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStatus(void) {
   /* TStatus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
   G__memfunc_setup("TStatus",728,G__G__ProofPlayer_282_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOk",374,G__G__ProofPlayer_282_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__ProofPlayer_282_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - mesg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInfo",661,G__G__ProofPlayer_282_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - mesg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__ProofPlayer_282_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__ProofPlayer_282_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextMesg",811,G__G__ProofPlayer_282_0_8, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExitStatus",1342,G__G__ProofPlayer_282_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResMemMax",1167,G__G__ProofPlayer_282_0_10, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVirtMemMax",1290,G__G__ProofPlayer_282_0_11, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExitStatus",1354,G__G__ProofPlayer_282_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - est", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMemValues",1211,G__G__ProofPlayer_282_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 '-1' vmem l - 'Long_t' 0 '-1' rmem "
"g - 'Bool_t' 0 'kFALSE' master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_282_0_14, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStatus::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_282_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatus::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_282_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStatus::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_282_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStatus::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_282_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_282_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatus::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_282_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStatus::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_282_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatus::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_282_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStatus::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStatus", 854, G__G__ProofPlayer_282_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofPlayer(void) {
   /* TProofPlayer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer));
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 2, 0, "", "used to set gTQSender", (void*) NULL, 1);
   G__memfunc_setup("DrawCanvas",1002,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", "Canvas drawing via libProofDraw", (void*) NULL, 1);
   G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "specialized setup", (void*) NULL, 1);
   G__memfunc_setup("MergeOutput",1153,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopFeedback",1195,G__G__ProofPlayer_283_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "specialized teardown", (void*) NULL, 1);
   G__memfunc_setup("AssertSelector",1459,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - - 10 - selector_file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckMemUsage",1266,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"n - 'Long64_t' 1 - mfreq g - 'Bool_t' 1 - w80r "
"g - 'Bool_t' 1 - w80v u 'TString' - 1 - wmsg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MapOutputListToDataMembers",2643,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofPlayer",1223,G__G__ProofPlayer_283_0_9, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set U 'TSelector' - 0 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("JoinProcess",1135,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TList' - 0 - workers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPacketizer",1330,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSelect",1006,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - varexp "
"C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDrawArgs",1083,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"C - - 10 - var C - - 10 - sel "
"C - 'Option_t' 10 - opt u 'TString' - 1 - selector "
"u 'TString' - 1 - objname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleGetTreeHeader",1861,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleRecvHisto",1507,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FeedBackCanvas",1345,G__G__ProofPlayer_283_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 - create", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - abort i - 'Int_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddInput",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - inp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearInput",1015,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOutput",945,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOutputList",1357,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInputList",1228,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfResults",1635,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddQueryResult",1438,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - q", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentQuery",1561,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQueryResult",1461,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult), -1, 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveQueryResult",1795,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCurrentQuery",1573,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - q", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxDrawQueries",1726,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RestorePreviousQuery",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOutputObject",1521,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOutput",922,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Incorporate a list", (void*) NULL, 1);
   G__memfunc_setup("StoreOutput",1182,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
   G__memfunc_setup("StoreFeedback",1298,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
"n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
"n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
"f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
"f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
"U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
"n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
"f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
"f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - - U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Feedback",773,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CreateDrawFeedback",1767,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawFeedbackOption",2104,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TDrawFeedback' - 0 - f C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteDrawFeedback",1766,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TDrawFeedback' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - slave U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReinitSelector",1452,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateAutoBin",1301,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 1 - xmin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmin "
"d - 'Double_t' 1 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsClient",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetExitStatus",1354,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i 'TVirtualProofPlayer::EExitStatus' - 0 - st", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExitStatus",1342,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEventsProcessed",1853,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEventsProcessed",1830,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDispatchTimer",1629,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStopTimer",1235,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' abort "
"i - 'Int_t' 0 '0' timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInitTime",1103,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOutputFilePath",1738,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePartialResults",1870,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' queryend g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProcessing",1353,G__G__ProofPlayer_283_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProgressStatus",1785,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateProgressInfo",1860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_283_0_67, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_283_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_283_0_69, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_283_0_70, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_283_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_283_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_283_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_283_0_77, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_283_0_78, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPlayer", 1349, G__G__ProofPlayer_283_0_79, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofPlayerLocal(void) {
   /* TProofPlayerLocal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal));
   G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopFeedback",1195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProofPlayerLocal",1714,G__G__ProofPlayer_286_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' client", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsClient",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,G__G__ProofPlayer_286_0_5, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
"C - - 10 - selector n - 'Long64_t' 0 '-1' nentries "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Process",735,G__G__ProofPlayer_286_0_6, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
"U 'TSelector' - 0 - selector n - 'Long64_t' 0 '-1' nentries "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set U 'TSelector' - 0 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_286_0_9, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerLocal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_286_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLocal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_286_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerLocal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_286_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerLocal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_286_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_286_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLocal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_286_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLocal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_286_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLocal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_286_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLocal::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPlayerLocal", 1840, G__G__ProofPlayer_286_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofPlayerSlave(void) {
   /* TProofPlayerSlave */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave));
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopFeedback",1195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProofPlayerSlave",1730,G__G__ProofPlayer_287_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave), -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 '0' socket", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleGetTreeHeader",1861,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_287_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerSlave::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_287_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSlave::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_287_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerSlave::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_287_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerSlave::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_287_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_287_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSlave::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_287_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSlave::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_287_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSlave::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_287_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSlave::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPlayerSlave", 1856, G__G__ProofPlayer_287_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofPlayerSuperMaster(void) {
   /* TProofPlayerSuperMaster */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster));
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProofPlayerSuperMaster",2370,G__G__ProofPlayer_288_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set C - - 10 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"U 'TDSet' - 0 - set U 'TSelector' - 0 - selector "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
"n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
"f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
"f - 'Float_t' 0 - mbrti", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - pi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSlave' - 0 - sl n - 'Long64_t' 0 - total "
"n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
"U 'TSlave' - 0 - sl n - 'Long64_t' 0 - total "
"n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
"f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
"f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TSlave' - 0 - sl U 'TProofProgressInfo' - 0 - pi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_288_0_12, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerSuperMaster::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_288_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSuperMaster::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_288_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerSuperMaster::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_288_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerSuperMaster::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_288_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_288_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSuperMaster::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_288_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSuperMaster::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_288_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSuperMaster::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_288_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSuperMaster::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPlayerSuperMaster", 2496, G__G__ProofPlayer_288_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStatsFeedback(void) {
   /* TStatsFeedback */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatsFeedback));
   G__memfunc_setup("TStatsFeedback",1384,G__G__ProofPlayer_289_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatsFeedback), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Feedback",773,G__G__ProofPlayer_289_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofPlayer_289_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStatsFeedback::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_289_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatsFeedback::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_289_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStatsFeedback::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_289_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStatsFeedback::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_289_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_289_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatsFeedback::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_289_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStatsFeedback::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_289_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatsFeedback::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_289_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStatsFeedback::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStatsFeedback", 1510, G__G__ProofPlayer_289_0_17, (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__ProofPlayer() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__ProofPlayer() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__ProofPlayer() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__ProofPlayerLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProof = { "TProof" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TDrawFeedback = { "TDrawFeedback" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TDSet = { "TDSet" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TDSetElement = { "TDSetElement" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TSelector = { "TSelector" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TIter = { "TIter" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TTreeCache = { "TTreeCache" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEventList = { "TEventList" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEntryList = { "TEntryList" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEventIter = { "TEventIter" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEventItercLcLEIterType = { "TEventIter::EIterType" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEventIterUnit = { "TEventIterUnit" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEventIterObj = { "TEventIterObj" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TEventIterTree = { "TEventIterTree" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TOutputListSelectorDataMap = { "TOutputListSelectorDataMap" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TSlave = { "TSlave" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TSocket = { "TSocket" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofProgressStatus = { "TProofProgressStatus" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TTime = { "TTime" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TMessage = { "TMessage" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TNtuple = { "TNtuple" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TNtupleD = { "TNtupleD" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofProgressInfo = { "TProofProgressInfo" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualPacketizer = { "TVirtualPacketizer" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt = { "TVirtualPacketizer::EUseEstOpt" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits = { "TVirtualPacketizer::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TSortedList = { "TSortedList" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizerAdaptive = { "TPacketizerAdaptive" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode = { "TPacketizerAdaptive::TFileNode" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat = { "TPacketizerAdaptive::TFileStat" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizerFile = { "TPacketizerFile" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizer = { "TPacketizer" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizercLcLTFileNode = { "TPacketizer::TFileNode" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizercLcLTFileStat = { "TPacketizer::TFileStat" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizerMulti = { "TPacketizerMulti" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPacketizerUnit = { "TPacketizerUnit" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TTimeStamp = { "TTimeStamp" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualPerfStats = { "TVirtualPerfStats" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType = { "TVirtualPerfStats::EEventType" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TH1D = { "TH1D" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TH1I = { "TH1I" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TH2D = { "TH2D" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPerfEvent = { "TPerfEvent" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TPerfStats = { "TPerfStats" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofMonSender = { "TProofMonSender" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_THLimitsFinder = { "THLimitsFinder" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofLimitsFinder = { "TProofLimitsFinder" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofMonSendercLcLEConfigBits = { "TProofMonSender::EConfigBits" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualMonitoringWriter = { "TVirtualMonitoringWriter" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofMonSenderML = { "TProofMonSenderML" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofMonSenderSQL = { "TProofMonSenderSQL" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TQueryResult = { "TQueryResult" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualProofPlayer = { "TVirtualProofPlayer" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus = { "TVirtualProofPlayer::EExitStatus" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TArrayL64 = { "TArrayL64" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TArrayF = { "TArrayF" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerLite = { "TProofPlayerLite" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerRemote = { "TProofPlayerRemote" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TMutex = { "TMutex" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TStatus = { "TStatus" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayer = { "TProofPlayer" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits = { "TProofPlayer::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerLocal = { "TProofPlayerLocal" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerSlave = { "TProofPlayerSlave" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerSuperMaster = { "TProofPlayerSuperMaster" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TStatsFeedback = { "TStatsFeedback" , 99 , -1 };
G__linked_taginfo G__G__ProofPlayerLN_TStatuscLcLEProcStatus = { "TStatus::EProcStatus" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__ProofPlayer() {
  G__G__ProofPlayerLN_TClass.tagnum = -1 ;
  G__G__ProofPlayerLN_TBuffer.tagnum = -1 ;
  G__G__ProofPlayerLN_TDirectory.tagnum = -1 ;
  G__G__ProofPlayerLN_TMemberInspector.tagnum = -1 ;
  G__G__ProofPlayerLN_TObject.tagnum = -1 ;
  G__G__ProofPlayerLN_TNamed.tagnum = -1 ;
  G__G__ProofPlayerLN_TCollection.tagnum = -1 ;
  G__G__ProofPlayerLN_TString.tagnum = -1 ;
  G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ProofPlayerLN_TList.tagnum = -1 ;
  G__G__ProofPlayerLN_TObjArray.tagnum = -1 ;
  G__G__ProofPlayerLN_TTimer.tagnum = -1 ;
  G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ProofPlayerLN_TQObject.tagnum = -1 ;
  G__G__ProofPlayerLN_TProof.tagnum = -1 ;
  G__G__ProofPlayerLN_THashList.tagnum = -1 ;
  G__G__ProofPlayerLN_TSeqCollection.tagnum = -1 ;
  G__G__ProofPlayerLN_TDrawFeedback.tagnum = -1 ;
  G__G__ProofPlayerLN_TDSet.tagnum = -1 ;
  G__G__ProofPlayerLN_TDSetElement.tagnum = -1 ;
  G__G__ProofPlayerLN_TFile.tagnum = -1 ;
  G__G__ProofPlayerLN_TSelector.tagnum = -1 ;
  G__G__ProofPlayerLN_TIter.tagnum = -1 ;
  G__G__ProofPlayerLN_TTree.tagnum = -1 ;
  G__G__ProofPlayerLN_TTreeCache.tagnum = -1 ;
  G__G__ProofPlayerLN_TEventList.tagnum = -1 ;
  G__G__ProofPlayerLN_TEntryList.tagnum = -1 ;
  G__G__ProofPlayerLN_TEventIter.tagnum = -1 ;
  G__G__ProofPlayerLN_TEventItercLcLEIterType.tagnum = -1 ;
  G__G__ProofPlayerLN_TEventIterUnit.tagnum = -1 ;
  G__G__ProofPlayerLN_TEventIterObj.tagnum = -1 ;
  G__G__ProofPlayerLN_TEventIterTree.tagnum = -1 ;
  G__G__ProofPlayerLN_TOutputListSelectorDataMap.tagnum = -1 ;
  G__G__ProofPlayerLN_TSlave.tagnum = -1 ;
  G__G__ProofPlayerLN_TSocket.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofProgressStatus.tagnum = -1 ;
  G__G__ProofPlayerLN_TTime.tagnum = -1 ;
  G__G__ProofPlayerLN_TMap.tagnum = -1 ;
  G__G__ProofPlayerLN_TMessage.tagnum = -1 ;
  G__G__ProofPlayerLN_TNtuple.tagnum = -1 ;
  G__G__ProofPlayerLN_TNtupleD.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofProgressInfo.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualPacketizer.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits.tagnum = -1 ;
  G__G__ProofPlayerLN_TSortedList.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizerAdaptive.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat.tagnum = -1 ;
  G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__ProofPlayerLN_TStopwatch.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizerFile.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizer.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizercLcLTFileNode.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizercLcLTFileStat.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizerMulti.tagnum = -1 ;
  G__G__ProofPlayerLN_TPacketizerUnit.tagnum = -1 ;
  G__G__ProofPlayerLN_TTimeStamp.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualPerfStats.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType.tagnum = -1 ;
  G__G__ProofPlayerLN_TH1D.tagnum = -1 ;
  G__G__ProofPlayerLN_TH1I.tagnum = -1 ;
  G__G__ProofPlayerLN_TH2D.tagnum = -1 ;
  G__G__ProofPlayerLN_TPerfEvent.tagnum = -1 ;
  G__G__ProofPlayerLN_TPerfStats.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofMonSender.tagnum = -1 ;
  G__G__ProofPlayerLN_TH1.tagnum = -1 ;
  G__G__ProofPlayerLN_THLimitsFinder.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofLimitsFinder.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofMonSendercLcLEConfigBits.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualMonitoringWriter.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofMonSenderML.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofMonSenderSQL.tagnum = -1 ;
  G__G__ProofPlayerLN_TQueryResult.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualProofPlayer.tagnum = -1 ;
  G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus.tagnum = -1 ;
  G__G__ProofPlayerLN_TArrayL64.tagnum = -1 ;
  G__G__ProofPlayerLN_TArrayF.tagnum = -1 ;
  G__G__ProofPlayerLN_TArrayI.tagnum = -1 ;
  G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayerLite.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayerRemote.tagnum = -1 ;
  G__G__ProofPlayerLN_TMutex.tagnum = -1 ;
  G__G__ProofPlayerLN_TStatus.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayer.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayerLocal.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayerSlave.tagnum = -1 ;
  G__G__ProofPlayerLN_TProofPlayerSuperMaster.tagnum = -1 ;
  G__G__ProofPlayerLN_TStatsFeedback.tagnum = -1 ;
  G__G__ProofPlayerLN_TStatuscLcLEProcStatus.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__ProofPlayer() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TCollection);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TString);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TList);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTimer);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProof);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_THashList);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSeqCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDrawFeedback),sizeof(TDrawFeedback),-1,292096,"Present PROOF query feedback",G__setup_memvarTDrawFeedback,G__setup_memfuncTDrawFeedback);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDSet);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDSetElement);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TFile);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSelector);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TIter);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTree);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTreeCache);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventList);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEntryList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIter),sizeof(TEventIter),-1,324869,"Event iterator used by TProofPlayer's",G__setup_memvarTEventIter,G__setup_memfuncTEventIter);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventItercLcLEIterType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIterUnit),sizeof(TEventIterUnit),-1,324864,"Event iterator for objects",G__setup_memvarTEventIterUnit,G__setup_memfuncTEventIterUnit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIterObj),sizeof(TEventIterObj),-1,324864,"Event iterator for objects",G__setup_memvarTEventIterObj,G__setup_memfuncTEventIterObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIterTree),sizeof(TEventIterTree),-1,324864,"Event iterator for Trees",G__setup_memvarTEventIterTree,G__setup_memfuncTEventIterTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TOutputListSelectorDataMap),sizeof(TOutputListSelectorDataMap),-1,292096,"Converter from output list to TSelector data members",G__setup_memvarTOutputListSelectorDataMap,G__setup_memfuncTOutputListSelectorDataMap);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSlave);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSocket);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofProgressStatus);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTime);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMap);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMessage);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TNtuple);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TNtupleD);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofProgressInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPacketizer),sizeof(TVirtualPacketizer),-1,327168,"Generate work packets for parallel processing",G__setup_memvarTVirtualPacketizer,G__setup_memfuncTVirtualPacketizer);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSortedList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerAdaptive),sizeof(TPacketizerAdaptive),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerAdaptive,G__setup_memfuncTPacketizerAdaptive);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TStopwatch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerFile),sizeof(TPacketizerFile),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerFile,G__setup_memfuncTPacketizerFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizer),sizeof(TPacketizer),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizer,G__setup_memfuncTPacketizer);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizercLcLTFileNode);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizercLcLTFileStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerMulti),sizeof(TPacketizerMulti),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerMulti,G__setup_memfuncTPacketizerMulti);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerUnit),sizeof(TPacketizerUnit),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerUnit,G__setup_memfuncTPacketizerUnit);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTimeStamp);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPerfStats);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH1D);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH1I);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH2D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPerfEvent),sizeof(TPerfEvent),-1,292096,"Class holding TProof Event Info",G__setup_memvarTPerfEvent,G__setup_memfuncTPerfEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPerfStats),sizeof(TPerfStats),-1,62464,"Class for collecting PROOF statistics",G__setup_memvarTPerfStats,G__setup_memfuncTPerfStats);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofMonSender),sizeof(TProofMonSender),-1,324867,"Interface for PROOF monitoring",G__setup_memvarTProofMonSender,G__setup_memfuncTProofMonSender);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH1);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_THLimitsFinder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofLimitsFinder),sizeof(TProofLimitsFinder),-1,29952,"Find and communicate best axis limits",G__setup_memvarTProofLimitsFinder,G__setup_memfuncTProofLimitsFinder);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofMonSendercLcLEConfigBits);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualMonitoringWriter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofMonSenderML),sizeof(TProofMonSenderML),-1,324608,"Interface for PROOF monitoring",G__setup_memvarTProofMonSenderML,G__setup_memfuncTProofMonSenderML);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofMonSenderSQL),sizeof(TProofMonSenderSQL),-1,324608,"Interface for PROOF monitoring",G__setup_memvarTProofMonSenderSQL,G__setup_memfuncTProofMonSenderSQL);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TQueryResult);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualProofPlayer);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TArrayL64);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TArrayF);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TArrayI);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerLite),sizeof(TProofPlayerLite),-1,292096,"PROOF player running in PROOF-Lite",G__setup_memvarTProofPlayerLite,G__setup_memfuncTProofPlayerLite);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerRemote),sizeof(TProofPlayerRemote),-1,292096,"PROOF player running on master server",G__setup_memvarTProofPlayerRemote,G__setup_memfuncTProofPlayerRemote);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMutex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TStatus),sizeof(TStatus),-1,128256,"Status class",G__setup_memvarTStatus,G__setup_memfuncTStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayer),sizeof(TProofPlayer),-1,292096,"Basic PROOF player",G__setup_memvarTProofPlayer,G__setup_memfuncTProofPlayer);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerLocal),sizeof(TProofPlayerLocal),-1,292096,"PROOF player running on client",G__setup_memvarTProofPlayerLocal,G__setup_memfuncTProofPlayerLocal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerSlave),sizeof(TProofPlayerSlave),-1,291072,"PROOF player running on slave server",G__setup_memvarTProofPlayerSlave,G__setup_memfuncTProofPlayerSlave);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),sizeof(TProofPlayerSuperMaster),-1,292096,"PROOF player running on super master",G__setup_memvarTProofPlayerSuperMaster,G__setup_memfuncTProofPlayerSuperMaster);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TStatsFeedback),sizeof(TStatsFeedback),-1,292096,"Present PROOF query feedback",G__setup_memvarTStatsFeedback,G__setup_memfuncTStatsFeedback);
   G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TStatuscLcLEProcStatus);
}
extern "C" void G__cpp_setupG__ProofPlayer(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__ProofPlayer()");
  G__set_cpp_environmentG__ProofPlayer();
  G__cpp_setup_tagtableG__ProofPlayer();

  G__cpp_setup_inheritanceG__ProofPlayer();

  G__cpp_setup_typetableG__ProofPlayer();

  G__cpp_setup_memvarG__ProofPlayer();

  G__cpp_setup_memfuncG__ProofPlayer();
  G__cpp_setup_globalG__ProofPlayer();
  G__cpp_setup_funcG__ProofPlayer();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__ProofPlayer();
  return;
}
class G__cpp_setup_initG__ProofPlayer {
  public:
    G__cpp_setup_initG__ProofPlayer() { G__add_setup_func("G__ProofPlayer",(G__incsetup)(&G__cpp_setupG__ProofPlayer)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__ProofPlayer() { G__remove_setup_func("G__ProofPlayer"); }
};
G__cpp_setup_initG__ProofPlayer G__cpp_setup_initializerG__ProofPlayer;