//
// File generated by core/utils/src/rootcint_tmp at Mon Aug 14 13:02:01 2017

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

#define R__DICTIONARY_FILENAME proofdIproofbenchdIsrcdIG__ProofBench
#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__ProofBench.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

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

// START OF SHADOWS

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

namespace ROOTDict {
   void TProofPerfAnalysis_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofPerfAnalysis(void *p);
   static void deleteArray_TProofPerfAnalysis(void *p);
   static void destruct_TProofPerfAnalysis(void *p);

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

namespace ROOTDict {
   void TPBReadType_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPBReadType(void *p = 0);
   static void *newArray_TPBReadType(Long_t size, void *p);
   static void delete_TPBReadType(void *p);
   static void deleteArray_TPBReadType(void *p);
   static void destruct_TPBReadType(void *p);

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

namespace ROOTDict {
   void TPBHistType_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPBHistType(void *p = 0);
   static void *newArray_TPBHistType(Long_t size, void *p);
   static void delete_TPBHistType(void *p);
   static void deleteArray_TPBHistType(void *p);
   static void destruct_TPBHistType(void *p);

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

namespace ROOTDict {
   void TPBHandleDSType_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPBHandleDSType(void *p = 0);
   static void *newArray_TPBHandleDSType(Long_t size, void *p);
   static void delete_TPBHandleDSType(void *p);
   static void deleteArray_TPBHandleDSType(void *p);
   static void destruct_TPBHandleDSType(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TPBHandleDSType*)
   {
      ::TPBHandleDSType *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPBHandleDSType >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPBHandleDSType", ::TPBHandleDSType::Class_Version(), "include/TProofBenchTypes.h", 87,
                  typeid(::TPBHandleDSType), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TPBHandleDSType::Dictionary, isa_proxy, 4,
                  sizeof(::TPBHandleDSType) );
      instance.SetNew(&new_TPBHandleDSType);
      instance.SetNewArray(&newArray_TPBHandleDSType);
      instance.SetDelete(&delete_TPBHandleDSType);
      instance.SetDeleteArray(&deleteArray_TPBHandleDSType);
      instance.SetDestructor(&destruct_TPBHandleDSType);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TPBHandleDSType*)
   {
      return GenerateInitInstanceLocal((::TPBHandleDSType*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPBHandleDSType*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TProofBenchRun_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofBenchRun(void *p);
   static void deleteArray_TProofBenchRun(void *p);
   static void destruct_TProofBenchRun(void *p);

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

namespace ROOTDict {
   void TProofBenchDataSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofBenchDataSet(void *p = 0);
   static void *newArray_TProofBenchDataSet(Long_t size, void *p);
   static void delete_TProofBenchDataSet(void *p);
   static void deleteArray_TProofBenchDataSet(void *p);
   static void destruct_TProofBenchDataSet(void *p);

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

namespace ROOTDict {
   void TProofNodes_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofNodes(void *p);
   static void deleteArray_TProofNodes(void *p);
   static void destruct_TProofNodes(void *p);

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

namespace ROOTDict {
   void TProofBenchRunDataRead_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofBenchRunDataRead(void *p);
   static void deleteArray_TProofBenchRunDataRead(void *p);
   static void destruct_TProofBenchRunDataRead(void *p);

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

namespace ROOTDict {
   void TProofBenchRunCPU_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProofBenchRunCPU(void *p = 0);
   static void *newArray_TProofBenchRunCPU(Long_t size, void *p);
   static void delete_TProofBenchRunCPU(void *p);
   static void deleteArray_TProofBenchRunCPU(void *p);
   static void destruct_TProofBenchRunCPU(void *p);

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

namespace ROOTDict {
   void TProofBench_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProofBench(void *p);
   static void deleteArray_TProofBench(void *p);
   static void destruct_TProofBench(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void TProofBench::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofBench.
      TClass *R__cl = ::TProofBench::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnlinkOutfile", &fUnlinkOutfile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProofDS", &fProofDS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutFile", &fOutFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutFileName", &fOutFileName);
      R__insp.InspectMember(fOutFileName, "fOutFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNtries", &fNtries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistType", &fHistType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNHist", &fNHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadType", &fReadType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSet", &fDataSet);
      R__insp.InspectMember(fDataSet, "fDataSet.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNFilesWrk", &fNFilesWrk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumWrkMax", &fNumWrkMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReleaseCache", &fReleaseCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCPUSel", &fCPUSel);
      R__insp.InspectMember(fCPUSel, "fCPUSel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCPUPar", &fCPUPar);
      R__insp.InspectMember(fCPUPar, "fCPUPar.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSel", &fDataSel);
      R__insp.InspectMember(fDataSel, "fDataSel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataPar", &fDataPar);
      R__insp.InspectMember(fDataPar, "fDataPar.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataGenSel", &fDataGenSel);
      R__insp.InspectMember(fDataGenSel, "fDataGenSel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataGenPar", &fDataGenPar);
      R__insp.InspectMember(fDataGenPar, "fDataGenPar.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRunCPU", &fRunCPU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRunDS", &fRunDS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDS", &fDS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &fDebug);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDescription", &fDescription);
      TObject::ShowMembers(R__insp);
}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TProofBench(void *p) {
      delete ((::TProofBench*)p);
   }
   static void deleteArray_TProofBench(void *p) {
      delete [] ((::TProofBench*)p);
   }
   static void destruct_TProofBench(void *p) {
      typedef ::TProofBench current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofBench

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

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

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

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TProofBenchDataSet(void *p) {
      return  p ? new(p) ::TProofBenchDataSet : new ::TProofBenchDataSet;
   }
   static void *newArray_TProofBenchDataSet(Long_t nElements, void *p) {
      return p ? new(p) ::TProofBenchDataSet[nElements] : new ::TProofBenchDataSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofBenchDataSet(void *p) {
      delete ((::TProofBenchDataSet*)p);
   }
   static void deleteArray_TProofBenchDataSet(void *p) {
      delete [] ((::TProofBenchDataSet*)p);
   }
   static void destruct_TProofBenchDataSet(void *p) {
      typedef ::TProofBenchDataSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofBenchDataSet

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

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

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

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TProofBenchRun(void *p) {
      delete ((::TProofBenchRun*)p);
   }
   static void deleteArray_TProofBenchRun(void *p) {
      delete [] ((::TProofBenchRun*)p);
   }
   static void destruct_TProofBenchRun(void *p) {
      typedef ::TProofBenchRun current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofBenchRun

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

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

//______________________________________________________________________________
void TProofBenchRunCPU::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofBenchRunCPU.
      TClass *R__cl = ::TProofBenchRunCPU::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistType", &fHistType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNHists", &fNHists);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEvents", &fNEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTries", &fNTries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStop", &fStop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStep", &fStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDraw", &fDraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &fDebug);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirProofBench", &fDirProofBench);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListPerfPlots", &fListPerfPlots);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_perfstat_event", &fProfile_perfstat_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist_perfstat_event", &fHist_perfstat_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_perfstat_evtmax", &fProfile_perfstat_evtmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNorm_perfstat_evtmax", &fNorm_perfstat_evtmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_queryresult_event", &fProfile_queryresult_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNorm_queryresult_event", &fNorm_queryresult_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_cpu_eff", &fProfile_cpu_eff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfLegend", &fProfLegend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNormLegend", &fNormLegend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      TProofBenchRun::ShowMembers(R__insp);
}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TProofBenchRunCPU(void *p) {
      return  p ? new(p) ::TProofBenchRunCPU : new ::TProofBenchRunCPU;
   }
   static void *newArray_TProofBenchRunCPU(Long_t nElements, void *p) {
      return p ? new(p) ::TProofBenchRunCPU[nElements] : new ::TProofBenchRunCPU[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProofBenchRunCPU(void *p) {
      delete ((::TProofBenchRunCPU*)p);
   }
   static void deleteArray_TProofBenchRunCPU(void *p) {
      delete [] ((::TProofBenchRunCPU*)p);
   }
   static void destruct_TProofBenchRunCPU(void *p) {
      typedef ::TProofBenchRunCPU current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofBenchRunCPU

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

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

//______________________________________________________________________________
void TProofBenchRunDataRead::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofBenchRunDataRead.
      TClass *R__cl = ::TProofBenchRunDataRead::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(), "*fReadType", &fReadType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDS", &fDS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEvents", &fNEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTries", &fNTries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStop", &fStop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStep", &fStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &fDebug);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilesPerWrk", &fFilesPerWrk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReleaseCache", &fReleaseCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirProofBench", &fDirProofBench);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListPerfPlots", &fListPerfPlots);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_perfstat_event", &fProfile_perfstat_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist_perfstat_event", &fHist_perfstat_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_perfstat_evtmax", &fProfile_perfstat_evtmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNorm_perfstat_evtmax", &fNorm_perfstat_evtmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_queryresult_event", &fProfile_queryresult_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNorm_queryresult_event", &fNorm_queryresult_event);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_perfstat_IO", &fProfile_perfstat_IO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist_perfstat_IO", &fHist_perfstat_IO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_perfstat_IOmax", &fProfile_perfstat_IOmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNorm_perfstat_IOmax", &fNorm_perfstat_IOmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_queryresult_IO", &fProfile_queryresult_IO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNorm_queryresult_IO", &fNorm_queryresult_IO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfile_cpu_eff", &fProfile_cpu_eff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfLegend_evt", &fProfLegend_evt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNormLegend_evt", &fNormLegend_evt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProfLegend_mb", &fProfLegend_mb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNormLegend_mb", &fNormLegend_mb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCPerfProfiles", &fCPerfProfiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      TProofBenchRun::ShowMembers(R__insp);
}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TProofBenchRunDataRead(void *p) {
      delete ((::TProofBenchRunDataRead*)p);
   }
   static void deleteArray_TProofBenchRunDataRead(void *p) {
      delete [] ((::TProofBenchRunDataRead*)p);
   }
   static void destruct_TProofBenchRunDataRead(void *p) {
      typedef ::TProofBenchRunDataRead current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofBenchRunDataRead

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

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

//______________________________________________________________________________
void TProofNodes::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofNodes.
      TClass *R__cl = ::TProofNodes::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(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActiveNodes", &fActiveNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxWrksNode", &fMaxWrksNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinWrksNode", &fMinWrksNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNNodes", &fNNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNWrks", &fNWrks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNActiveWrks", &fNActiveWrks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCores", &fNCores);
      TObject::ShowMembers(R__insp);
}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TProofNodes(void *p) {
      delete ((::TProofNodes*)p);
   }
   static void deleteArray_TProofNodes(void *p) {
      delete [] ((::TProofNodes*)p);
   }
   static void destruct_TProofNodes(void *p) {
      typedef ::TProofNodes current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofNodes

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

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

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

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TPBReadType(void *p) {
      return  p ? new(p) ::TPBReadType : new ::TPBReadType;
   }
   static void *newArray_TPBReadType(Long_t nElements, void *p) {
      return p ? new(p) ::TPBReadType[nElements] : new ::TPBReadType[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPBReadType(void *p) {
      delete ((::TPBReadType*)p);
   }
   static void deleteArray_TPBReadType(void *p) {
      delete [] ((::TPBReadType*)p);
   }
   static void destruct_TPBReadType(void *p) {
      typedef ::TPBReadType current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TPBReadType

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

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

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

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TPBHistType(void *p) {
      return  p ? new(p) ::TPBHistType : new ::TPBHistType;
   }
   static void *newArray_TPBHistType(Long_t nElements, void *p) {
      return p ? new(p) ::TPBHistType[nElements] : new ::TPBHistType[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPBHistType(void *p) {
      delete ((::TPBHistType*)p);
   }
   static void deleteArray_TPBHistType(void *p) {
      delete [] ((::TPBHistType*)p);
   }
   static void destruct_TPBHistType(void *p) {
      typedef ::TPBHistType current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TPBHistType

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

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

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

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TPBHandleDSType(void *p) {
      return  p ? new(p) ::TPBHandleDSType : new ::TPBHandleDSType;
   }
   static void *newArray_TPBHandleDSType(Long_t nElements, void *p) {
      return p ? new(p) ::TPBHandleDSType[nElements] : new ::TPBHandleDSType[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPBHandleDSType(void *p) {
      delete ((::TPBHandleDSType*)p);
   }
   static void deleteArray_TPBHandleDSType(void *p) {
      delete [] ((::TPBHandleDSType*)p);
   }
   static void destruct_TPBHandleDSType(void *p) {
      typedef ::TPBHandleDSType current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TPBHandleDSType

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

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

//______________________________________________________________________________
void TProofPerfAnalysis::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProofPerfAnalysis.
      TClass *R__cl = ::TProofPerfAnalysis::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirName", &fDirName);
      R__insp.InspectMember(fDirName, "fDirName.");
      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(), "fWrksInfo", &fWrksInfo);
      R__insp.InspectMember(fWrksInfo, "fWrksInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilesInfo", &fFilesInfo);
      R__insp.InspectMember(fFilesInfo, "fFilesInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitTime", &fInitTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergeTime", &fMergeTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxTime", &fMaxTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvents", &fEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtRateMax", &fEvtRateMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBRateMax", &fMBRateMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatencyMax", &fLatencyMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvtRate", &fEvtRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvtRateRun", &fEvtRateRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMBRate", &fMBRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMBRateRun", &fMBRateRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtRateAvgMax", &fEvtRateAvgMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBRateAvgMax", &fMBRateAvgMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtRateAvg", &fEvtRateAvg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBRateAvg", &fMBRateAvg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileResult", &fFileResult);
      R__insp.InspectMember(fFileResult, "fFileResult.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveResult", &fSaveResult);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &fDebug);
      TNamed::ShowMembers(R__insp);
}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TProofPerfAnalysis(void *p) {
      delete ((::TProofPerfAnalysis*)p);
   }
   static void deleteArray_TProofPerfAnalysis(void *p) {
      delete [] ((::TProofPerfAnalysis*)p);
   }
   static void destruct_TProofPerfAnalysis(void *p) {
      typedef ::TProofPerfAnalysis current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TProofPerfAnalysis

/********************************************************
* proof/proofbench/src/G__ProofBench.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__ProofBench();

extern "C" void G__set_cpp_environmentG__ProofBench() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TProofPerfAnalysis.h");
  G__add_compiledheader("TProofBenchRun.h");
  G__add_compiledheader("TProofBenchRunDataRead.h");
  G__add_compiledheader("TProofNodes.h");
  G__add_compiledheader("TProofBenchDataSet.h");
  G__add_compiledheader("TProofBenchTypes.h");
  G__add_compiledheader("TProofBenchRunCPU.h");
  G__add_compiledheader("TProofBench.h");
  G__cpp_reset_tagtableG__ProofBench();
}
#include <new>
extern "C" int G__cpp_dllrevG__ProofBench() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TProofBenchRun */
static int G__G__ProofBench_154_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TProofBenchRun*) G__getstructoffset())->GetSelName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__ProofBench_154_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TProofBenchRun*) G__getstructoffset())->Run(
(Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TProofBenchRun*) G__getstructoffset())->Run((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TProofBenchRun*) G__getstructoffset())->Run((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TProofBenchRun*) G__getstructoffset())->Run((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TProofBenchRun*) G__getstructoffset())->Run((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TProofBenchRun*) G__getstructoffset())->Run((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TProofBenchRun*) G__getstructoffset())->Run((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofBench_154_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TProofBenchRun*) G__getstructoffset())->Run(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TProofBenchRun*) G__getstructoffset())->Run((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TProofBenchRun*) G__getstructoffset())->Run((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TProofBenchRun*) G__getstructoffset())->Run((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TProofBenchRun*) G__getstructoffset())->Run((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TProofBenchRun*) G__getstructoffset())->Run((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TProofBenchRun*) G__getstructoffset())->Run((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TProofBenchRunDataRead */
static int G__G__ProofBench_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProofBenchRunDataRead* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Int_t) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Int_t) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead(
(TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead((TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead((TProofBenchDataSet*) G__int(libp->para[0]), (TPBReadType*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunDataRead((TProofBenchDataSet*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TProofBenchRunDataRead((TProofBenchDataSet*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TProofBenchRunCPU */
static int G__G__ProofBench_165_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProofBenchRunCPU* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 12:
     //m: 12
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Int_t) G__int(libp->para[10]), (Int_t) G__int(libp->para[11]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Int_t) G__int(libp->para[10]), (Int_t) G__int(libp->para[11]));
     }
     break;
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Int_t) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Int_t) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
, (TProofNodes*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU(
(TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU((TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU((TPBHistType*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProofBenchRunCPU((TPBHistType*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TProofBenchRunCPU((TPBHistType*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TProofBenchRunCPU[n];
       } else {
         p = new((void*) gvp) TProofBenchRunCPU[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TProofBenchRunCPU;
       } else {
         p = new((void*) gvp) TProofBenchRunCPU;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__ProofBench_168_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      TProofBench::DrawCPU((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      TProofBench::DrawCPU((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      TProofBench::DrawCPU((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TProofBench::DrawCPU((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TProofBench::DrawCPU((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TProofBench::DrawCPU((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__ProofBench_168_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      TProofBench::DrawDataSet(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      TProofBench::DrawDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      TProofBench::DrawDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      TProofBench::DrawDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TProofBench::DrawDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TProofBench::DrawDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TProofBench::DrawDataSet((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

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

/* TProofPerfAnalysis */

/* TPBReadType */

/* TPBHistType */

/* TPBHandleDSType */

/* TProofBenchRun */

/* TProofBenchDataSet */

/* TProofNodes */

/* TProofBenchRunDataRead */

/* TProofBenchRunCPU */

/* TProofBench */

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

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

size_t G__get_sizep2memfuncG__ProofBench()
{
  G__Sizep2memfuncG__ProofBench 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__ProofBench() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis))) {
     TProofPerfAnalysis *G__Lderived;
     G__Lderived=(TProofPerfAnalysis*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis),G__get_linked_tagnum(&G__G__ProofBenchLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType))) {
     TPBReadType *G__Lderived;
     G__Lderived=(TPBReadType*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType))) {
     TPBHistType *G__Lderived;
     G__Lderived=(TPBHistType*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType))) {
     TPBHandleDSType *G__Lderived;
     G__Lderived=(TPBHandleDSType*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun))) {
     TProofBenchRun *G__Lderived;
     G__Lderived=(TProofBenchRun*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet))) {
     TProofBenchDataSet *G__Lderived;
     G__Lderived=(TProofBenchDataSet*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes))) {
     TProofNodes *G__Lderived;
     G__Lderived=(TProofNodes*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead))) {
     TProofBenchRunDataRead *G__Lderived;
     G__Lderived=(TProofBenchRunDataRead*)0x1000;
     {
       TProofBenchRun *G__Lpbase=(TProofBenchRun*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead),G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU))) {
     TProofBenchRunCPU *G__Lderived;
     G__Lderived=(TProofBenchRunCPU*)0x1000;
     {
       TProofBenchRun *G__Lpbase=(TProofBenchRun*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU),G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench))) {
     TProofBench *G__Lderived;
     G__Lderived=(TProofBench*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench),G__get_linked_tagnum(&G__G__ProofBenchLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

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

   /* 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("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__ProofBenchLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofBenchLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofBenchLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofBenchLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofBenchLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__ProofBenchLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofBenchLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofBenchLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofBenchLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBenchLN_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__ProofBenchLN_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__ProofBenchLN_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__ProofBenchLN_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__ProofBenchLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

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

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

   /* TProofPerfAnalysis */
static void G__setup_memvarTProofPerfAnalysis(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis));
   { TProofPerfAnalysis *p; p=(TProofPerfAnalysis*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TFile),-1,-1,4,"fFile=",0,"The open performance file");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fDirName=",0,"The name of the subdir with the perfomance tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fTreeName=",0,"The name of the performance tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TTree),-1,-1,4,"fTree=",0,"The performance tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TSortedList),-1,-1,4,"fWrksInfo=",0,"Sorted list of workers info");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TSortedList),-1,-1,4,"fFilesInfo=",0,"Sorted list of files info");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fInitTime=",0,"End of initialization time for this query");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMergeTime=",0,"Begin of merging time for this query");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMaxTime=",0,"Max time for this query (slowest worker)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH1F),-1,-1,4,"fEvents=",0,"Event distribution per worker");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH1F),-1,-1,4,"fPackets=",0,"Packet distribution per worker");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvtRateMax=",0,"Max event processing rate per packet");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMBRateMax=",0,"Max MB processing rate per packet");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLatencyMax=",0,"Max retrieval latency per packet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH1F),-1,-1,4,"fEvtRate=",0,"Event processing rate vs query time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH1F),-1,-1,4,"fEvtRateRun=",0,"Event processing rate running avg vs query time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH1F),-1,-1,4,"fMBRate=",0,"Byte processing rate vs query time");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH1F),-1,-1,4,"fMBRateRun=",0,"Byte processing rate running avg vs query time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvtRateAvgMax=",0,"Max running event processing rate");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMBRateAvgMax=",0,"Max running MB processing rate");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvtRateAvg=",0,"Average event processing rate");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMBRateAvg=",0,"Average MB processing rate");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fFileResult=",0,"File where to save basics of a run when requested");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSaveResult=",0,"Whether to save the results of a run");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDebug=",0,"Local verbosity level");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgDebug=",0,"Global verbosity on/off");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPBReadType */
static void G__setup_memvarTPBReadType(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType));
   { TPBReadType *p; p=(TPBReadType*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType),-1,-2,1,G__FastAllocString(2048).Format("kReadNotSpecified=%lldLL",(long long)TPBReadType::kReadNotSpecified).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType),-1,-2,1,G__FastAllocString(2048).Format("kReadFull=%lldLL",(long long)TPBReadType::kReadFull).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType),-1,-2,1,G__FastAllocString(2048).Format("kReadOpt=%lldLL",(long long)TPBReadType::kReadOpt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType),-1,-2,1,G__FastAllocString(2048).Format("kReadNo=%lldLL",(long long)TPBReadType::kReadNo).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType),-1,-1,4,"fType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPBHistType */
static void G__setup_memvarTPBHistType(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType));
   { TPBHistType *p; p=(TPBHistType*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType),-1,-2,1,G__FastAllocString(2048).Format("kHistNotSpecified=%lldLL",(long long)TPBHistType::kHistNotSpecified).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType),-1,-2,1,G__FastAllocString(2048).Format("kHist1D=%lldLL",(long long)TPBHistType::kHist1D).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType),-1,-2,1,G__FastAllocString(2048).Format("kHist2D=%lldLL",(long long)TPBHistType::kHist2D).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType),-1,-2,1,G__FastAllocString(2048).Format("kHist3D=%lldLL",(long long)TPBHistType::kHist3D).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType),-1,-2,1,G__FastAllocString(2048).Format("kHistAll=%lldLL",(long long)TPBHistType::kHistAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType),-1,-1,4,"fType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPBHandleDSType */
static void G__setup_memvarTPBHandleDSType(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType));
   { TPBHandleDSType *p; p=(TPBHandleDSType*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType),-1,-2,1,G__FastAllocString(2048).Format("kReleaseCache=%lldLL",(long long)TPBHandleDSType::kReleaseCache).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType),-1,-2,1,G__FastAllocString(2048).Format("kCheckCache=%lldLL",(long long)TPBHandleDSType::kCheckCache).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType),-1,-2,1,G__FastAllocString(2048).Format("kRemoveFiles=%lldLL",(long long)TPBHandleDSType::kRemoveFiles).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType),-1,-2,1,G__FastAllocString(2048).Format("kCopyFiles=%lldLL",(long long)TPBHandleDSType::kCopyFiles).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType),-1,-1,4,"fType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofBenchRun */
static void G__setup_memvarTProofBenchRun(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun));
   { TProofBenchRun *p; p=(TProofBenchRun*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProof),-1,-1,2,"fProof=",0,"Proof");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fSelName=",0,"Name of the selector to be run");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fParList=",0,"List of PARs to be loaded");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofBenchDataSet */
static void G__setup_memvarTProofBenchDataSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet));
   { TProofBenchDataSet *p; p=(TProofBenchDataSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProof),-1,-1,2,"fProof=",0,"proof");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofNodes */
static void G__setup_memvarTProofNodes(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes));
   { TProofNodes *p; p=(TProofNodes*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProof),-1,-1,4,"fProof=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TMap),-1,-1,4,"fNodes=",0,"Map of node infos");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TMap),-1,-1,4,"fActiveNodes=",0,"Map of active node infos");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxWrksNode=",0,"Max number of workers per node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMinWrksNode=",0,"Min number of workers per node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNNodes=",0,"Number of nodes");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNWrks=",0,"Number of workers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNActiveWrks=",0,"Number of active workers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNCores=",0,"Number of total cores");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofBenchRunDataRead */
static void G__setup_memvarTProofBenchRunDataRead(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead));
   { TProofBenchRunDataRead *p; p=(TProofBenchRunDataRead*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProof),-1,-1,4,"fProof=",0,"pointer to proof");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType),-1,-1,4,"fReadType=",0,"read type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet),-1,-1,4,"fDS=",0,"dataset operations handler");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNEvents=",0,"number of events per file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTries=",0,"number of tries");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStart=",0,"start number of workers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStop=",0,"stop number of workers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStep=",0,"test to be performed every fStep workers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDebug=",0,"debug switch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFilesPerWrk=",0,"# of files to be processed per worker");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReleaseCache=",0,"Release cache for data reads between runs ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TDirectory),-1,-1,4,"fDirProofBench=",0,"directory for proof outputs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes),-1,-1,4,"fNodes=",0,"list of nodes information");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TList),-1,-1,4,"fListPerfPlots=",0,"list of performance plots");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_perfstat_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH2),-1,-1,4,"fHist_perfstat_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_perfstat_evtmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fNorm_perfstat_evtmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_queryresult_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fNorm_queryresult_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_perfstat_IO=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH2),-1,-1,4,"fHist_perfstat_IO=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_perfstat_IOmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fNorm_perfstat_IOmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_queryresult_IO=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fNorm_queryresult_IO=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_cpu_eff=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TLegend),-1,-1,4,"fProfLegend_evt=",0,"Legend for profiles evts");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TLegend),-1,-1,4,"fNormLegend_evt=",0,"Legend for norms evts");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TLegend),-1,-1,4,"fProfLegend_mb=",0,"Legend for profiles mbs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TLegend),-1,-1,4,"fNormLegend_mb=",0,"Legend for norms mbs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TCanvas),-1,-1,4,"fCPerfProfiles=",0,"canvas for performance profile histograms");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fName=",0,"name of this run");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofBenchRunCPU */
static void G__setup_memvarTProofBenchRunCPU(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU));
   { TProofBenchRunCPU *p; p=(TProofBenchRunCPU*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType),-1,-1,4,"fHistType=",0,"histogram type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNHists=",0,"number of histograms");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNEvents=",0,"number of events to generate");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTries=",0,"number of tries ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStart=",0,"start number of workers to scan");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStop=",0,"stop number of workers to scan");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStep=",0,"test to be performed every fStep workers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDraw=",0,"draw switch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDebug=",0,"debug switch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TDirectory),-1,-1,4,"fDirProofBench=",0,"directory for proof outputs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes),-1,-1,4,"fNodes=",0,"node information");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TList),-1,-1,4,"fListPerfPlots=",0,"list of performance plots");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TCanvas),-1,-1,4,"fCanvas=",0,"canvas for performance plots");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_perfstat_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TH2),-1,-1,4,"fHist_perfstat_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_perfstat_evtmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fNorm_perfstat_evtmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_queryresult_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fNorm_queryresult_event=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProfile),-1,-1,4,"fProfile_cpu_eff=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TLegend),-1,-1,4,"fProfLegend=",0,"Legend for profiles");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TLegend),-1,-1,4,"fNormLegend=",0,"Legend for norms");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,4,"fName=",0,"name of CPU run");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProofBench */
static void G__setup_memvarTProofBench(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench));
   { TProofBench *p; p=(TProofBench*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUnlinkOutfile=",0,"Whether to remove empty output files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProof),-1,-1,2,"fProof=",0,"Proof");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProof),-1,-1,2,"fProofDS=",0,"Proof to be used for dataset actions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TFile),-1,-1,2,"fOutFile=",0,"Output file");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fOutFileName=",0,"Name of the output file");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNtries=",0,"Number of times a measurement is repeated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType),-1,-1,2,"fHistType=",0,"Type of histograms for CPU runs");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNHist=",0,"Number of histograms to be created in default CPU runs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType),-1,-1,2,"fReadType=",0,"Type of read (partial, full)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fDataSet=",0,"Name of the dataset");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNFilesWrk=",0,"Number of files generated files per worker");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumWrkMax=",0,"Max number of workers (required for dynamic setups)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReleaseCache=",0,"Release cache for data reads between runs ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fCPUSel=",0,"Selector to be used for CPU benchmarks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fCPUPar=",0,"List of par files to be loaded for CPU benchmarks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fDataSel=",0,"Selector to be used for data benchmarks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fDataPar=",0,"List of par files to be loaded for data benchmarks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fDataGenSel=",0,"Selector to be used for generate data for benchmarks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TString),-1,-1,2,"fDataGenPar=",0,"List of par files to be loaded to generate data for benchmarks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU),-1,-1,2,"fRunCPU=",0,"Instance to run CPU scans");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead),-1,-1,2,"fRunDS=",0,"Instance to run data-read scans");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet),-1,-1,2,"fDS=",0,"Instance to handle datasets operations");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDebug=",0,"Debug switch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TNamed),-1,-1,2,"fDescription=",0,"Strings describing the cluster for this test (saved in the output file)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFp1=",0,"Simple 1st degree polynomial");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFp1n=",0,"Normalized 1st degree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFp2=",0,"Simple 2nd degree polynomial");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFp2n=",0,"Normalized 2nd degree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFp3=",0,"Function with varying Rcpu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFp3n=",0,"Normalized Function with varying Rcpu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFio=",0,"Function used for I/O rate fits");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TF1),-1,-2,2,"fgFioV=",0,"Function used for I/O rate fits with non-constant Rcpu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TList),-1,-2,2,"fgGraphs=",0,"List of TGraphErrors created by Draw actions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofBenchLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTProofPerfAnalysis(void) {
   /* TProofPerfAnalysis */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis));
   G__memfunc_setup("CompareOrd",1004,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"C - - 10 - ord1 C - - 10 - ord2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillFileDist",1179,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"U 'TH1F' - 0 - hf U 'TH1F' - 0 - hb "
"U 'TH2F' - 0 - hx g - 'Bool_t' 0 'kFALSE' wdet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillFileDistOneSrv",1784,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TH1F' - 0 - hx g - 'Bool_t' 0 'kFALSE' wdet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillWrkInfo",1095,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillFileInfo",1171,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvasTitle",1406,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofBenchLN_TString), -1, 0, 1, 1, 4, 0, "C - - 10 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWrkFileList",1392,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TList' - 0 - wl U 'TList' - 0 - sl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadTree",784,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDraw",577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"U 'TObject' - 0 - o C - 'Option_t' 10 '\"\"' opt "
"C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofPerfAnalysis",1835,G__G__ProofBench_141_0_10, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis), -1, 0, 3, 1, 1, 0, 
"C - - 10 - perffile C - - 10 '\"\"' title "
"C - - 10 '\"PROOF_PerfStats\"' treename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofPerfAnalysis",1835,G__G__ProofBench_141_0_11, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofPerfAnalysis), -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__ProofBench_141_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WrkInfoOK",858,G__G__ProofBench_141_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EventDist",918,G__G__ProofBench_141_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", "Analyse event and packet distribution", (void*) NULL, 0);
   G__memfunc_setup("FileDist",788,G__G__ProofBench_141_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' writedet", "Analyse the file distribution", (void*) NULL, 0);
   G__memfunc_setup("LatencyPlot",1135,G__G__ProofBench_141_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' wrks", "Packet latency distribution vs time", (void*) NULL, 0);
   G__memfunc_setup("RatePlot",811,G__G__ProofBench_141_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' wrks", "Rate distribution vs time", (void*) NULL, 0);
   G__memfunc_setup("WorkerActivity",1479,G__G__ProofBench_141_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", "Analyse the worker activity", (void*) NULL, 0);
   G__memfunc_setup("PrintWrkInfo",1229,G__G__ProofBench_141_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '10' showlast", "Print workers info", (void*) NULL, 0);
   G__memfunc_setup("PrintWrkInfo",1229,G__G__ProofBench_141_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - wrk", "Print worker info by name", (void*) NULL, 0);
   G__memfunc_setup("PrintFileInfo",1305,G__G__ProofBench_141_0_21, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '10' showlast C - - 10 '\"\"' opt "
"C - - 10 '0' out", "Print file info", (void*) NULL, 0);
   G__memfunc_setup("PrintFileInfo",1305,G__G__ProofBench_141_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - fn C - - 10 '\"P\"' opt "
"C - - 10 '0' out", "Print file info by name", (void*) NULL, 0);
   G__memfunc_setup("FileProcPlot",1203,G__G__ProofBench_141_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fn C - - 10 '0' out", "Plot info about file processing", (void*) NULL, 0);
   G__memfunc_setup("FileRatePlot",1195,G__G__ProofBench_141_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' fns", "Plot info about file processing rates", (void*) NULL, 0);
   G__memfunc_setup("GetEvtRateAvgMax",1567,G__G__ProofBench_141_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Max running event processing rate", (void*) NULL, 0);
   G__memfunc_setup("GetMBRateAvgMax",1407,G__G__ProofBench_141_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Max running MB processing rate", (void*) NULL, 0);
   G__memfunc_setup("GetEvtRateAvg",1273,G__G__ProofBench_141_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Average event processing rate", (void*) NULL, 0);
   G__memfunc_setup("GetMBRateAvg",1113,G__G__ProofBench_141_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Average MB processing rate", (void*) NULL, 0);
   G__memfunc_setup("GetAverages",1102,G__G__ProofBench_141_0_29, 121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - evtmax d - 'Double_t' 1 - mbmax "
"d - 'Double_t' 1 - evt d - 'Double_t' 1 - mb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Summary",750,G__G__ProofBench_141_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Option_t' 10 '\"\"' opt C - - 10 '\"\"' out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSaveResult",1338,G__G__ProofBench_141_0_31, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 '\"results.root\"' file C - 'Option_t' 10 '\"RECREATE\"' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDebug",787,G__G__ProofBench_141_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' d", "Setter for the verbosity level", (void*) NULL, 0);
   G__memfunc_setup("SetgDebug",890,G__G__ProofBench_141_0_33, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "Overall verbosity level", (void*) G__func2void( (void (*)(Bool_t))(&TProofPerfAnalysis::SetgDebug) ), 0);
   G__memfunc_setup("Class",502,G__G__ProofBench_141_0_34, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPerfAnalysis::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_141_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPerfAnalysis::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_141_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPerfAnalysis::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_141_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPerfAnalysis::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_141_0_41, 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__ProofBench_141_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPerfAnalysis::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_141_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPerfAnalysis::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_141_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPerfAnalysis::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_141_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPerfAnalysis::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofPerfAnalysis", 1961, G__G__ProofBench_141_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPBReadType(void) {
   /* TPBReadType */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType));
   G__memfunc_setup("TPBReadType",1028,G__G__ProofBench_147_0_1, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType), -1, 0, 1, 1, 1, 0, "i 'TPBReadType::EReadType' - 0 'kReadOpt' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__ProofBench_147_0_2, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReadFull",971,G__G__ProofBench_147_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReadOpt",875,G__G__ProofBench_147_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReadNo",757,G__G__ProofBench_147_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofBench_147_0_7, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPBReadType::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_147_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBReadType::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_147_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPBReadType::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_147_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPBReadType::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_147_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__ProofBench_147_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBReadType::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_147_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPBReadType::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_147_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBReadType::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_147_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPBReadType::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPBReadType", 1028, G__G__ProofBench_147_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType), -1, 0, 1, 1, 1, 0, "u 'TPBReadType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPBReadType", 1154, G__G__ProofBench_147_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofBench_147_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType), -1, 1, 1, 1, 1, 0, "u 'TPBReadType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPBHistType(void) {
   /* TPBHistType */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType));
   G__memfunc_setup("TPBHistType",1056,G__G__ProofBench_149_0_1, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType), -1, 0, 1, 1, 1, 0, "i 'TPBHistType::EHistType' - 0 'kHist1D' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__ProofBench_149_0_2, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHist1D",713,G__G__ProofBench_149_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHist2D",714,G__G__ProofBench_149_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHist3D",715,G__G__ProofBench_149_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHistAll",877,G__G__ProofBench_149_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofBench_149_0_8, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPBHistType::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_149_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBHistType::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_149_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPBHistType::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_149_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPBHistType::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_149_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__ProofBench_149_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBHistType::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_149_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPBHistType::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_149_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBHistType::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_149_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPBHistType::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPBHistType", 1056, G__G__ProofBench_149_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType), -1, 0, 1, 1, 1, 0, "u 'TPBHistType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPBHistType", 1182, G__G__ProofBench_149_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__ProofBench_149_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType), -1, 1, 1, 1, 1, 0, "u 'TPBHistType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPBHandleDSType(void) {
   /* TPBHandleDSType */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType));
   G__memfunc_setup("TPBHandleDSType",1387,G__G__ProofBench_151_0_1, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType), -1, 0, 1, 1, 1, 0, "i 'TPBHandleDSType::EHandleDSType' - 0 'kReleaseCache' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__ProofBench_151_0_2, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReleaseCache",1361,G__G__ProofBench_151_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCheckCache",1134,G__G__ProofBench_151_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRemoveFiles",1309,G__G__ProofBench_151_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCopyFiles",1098,G__G__ProofBench_151_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofBench_151_0_8, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPBHandleDSType::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_151_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBHandleDSType::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_151_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPBHandleDSType::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_151_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPBHandleDSType::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_151_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__ProofBench_151_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBHandleDSType::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_151_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPBHandleDSType::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_151_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPBHandleDSType::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_151_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPBHandleDSType::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TPBHandleDSType", 1387, G__G__ProofBench_151_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType), -1, 0, 1, 1, 1, 0, "u 'TPBHandleDSType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPBHandleDSType", 1513, G__G__ProofBench_151_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__ProofBench_151_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHandleDSType), -1, 1, 1, 1, 1, 0, "u 'TPBHandleDSType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofBenchRun(void) {
   /* TProofBenchRun */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun));
   G__memfunc_setup("GetSelName",965,G__G__ProofBench_154_0_2, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParList",991,G__G__ProofBench_154_0_3, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelName",977,G__G__ProofBench_154_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParList",1003,G__G__ProofBench_154_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - pars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Run",309,G__G__ProofBench_154_0_6, 121, -1, -1, 0, 7, 1, 1, 0, 
"n - 'Long64_t' 0 - nevents i - 'Int_t' 0 '-1' start "
"i - 'Int_t' 0 '-1' stop i - 'Int_t' 0 '-1' step "
"i - 'Int_t' 0 '-1' ntries i - 'Int_t' 0 '-1' debug "
"i - 'Int_t' 0 '-1' draw", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Run",309,G__G__ProofBench_154_0_7, 121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - dset i - 'Int_t' 0 '-1' start "
"i - 'Int_t' 0 '-1' stop i - 'Int_t' 0 '-1' step "
"i - 'Int_t' 0 '-1' ntries i - 'Int_t' 0 '-1' debug "
"i - 'Int_t' 0 '-1' draw", (char*)NULL, (void*) NULL, 3);
   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, 3);
   G__memfunc_setup("Class",502,G__G__ProofBench_154_0_9, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofBenchRun::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_154_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRun::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_154_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofBenchRun::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_154_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofBenchRun::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_154_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__ProofBench_154_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRun::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_154_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchRun::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_154_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRun::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_154_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchRun::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProofBenchRun", 1517, G__G__ProofBench_154_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__ProofBench_154_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRun), -1, 1, 1, 1, 1, 0, "u 'TProofBenchRun' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofBenchDataSet(void) {
   /* TProofBenchDataSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet));
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"C - - 10 - dset U 'TObject' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofBenchDataSet",1760,G__G__ProofBench_161_0_2, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsProof",706,G__G__ProofBench_161_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyFiles",910,G__G__ProofBench_161_0_4, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - dset C - - 10 - destdir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseCache",1173,G__G__ProofBench_161_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveFiles",1121,G__G__ProofBench_161_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__ProofBench_161_0_7, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofBenchDataSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_161_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchDataSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_161_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofBenchDataSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_161_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofBenchDataSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_161_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__ProofBench_161_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchDataSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_161_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchDataSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_161_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchDataSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_161_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchDataSet::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofBenchDataSet", 1760, G__G__ProofBench_161_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet), -1, 0, 1, 1, 1, 0, "u 'TProofBenchDataSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofBenchDataSet", 1886, G__G__ProofBench_161_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofBench_161_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchDataSet), -1, 1, 1, 1, 1, 0, "u 'TProofBenchDataSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofNodes(void) {
   /* TProofNodes */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes));
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofNodes",1107,G__G__ProofBench_162_0_2, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - proof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ActivateWorkers",1566,G__G__ProofBench_162_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nwrks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ActivateWorkers",1566,G__G__ProofBench_162_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - workers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxWrksPerNode",1690,G__G__ProofBench_162_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNWorkersCluster",1853,G__G__ProofBench_162_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNNodes",871,G__G__ProofBench_162_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNCores",874,G__G__ProofBench_162_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinWrksPerNode",1688,G__G__ProofBench_162_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNActives",1085,G__G__ProofBench_162_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapOfNodes",1260,G__G__ProofBench_162_0_11, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TMap), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapOfActiveNodes",1864,G__G__ProofBench_162_0_12, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TMap), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__ProofBench_162_0_14, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofNodes::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_162_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofNodes::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_162_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofNodes::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_162_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofNodes::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_162_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__ProofBench_162_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofNodes::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_162_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofNodes::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_162_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofNodes::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_162_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofNodes::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofNodes", 1107, G__G__ProofBench_162_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes), -1, 0, 1, 1, 1, 0, "u 'TProofNodes' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofNodes", 1233, G__G__ProofBench_162_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofBench_162_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofNodes), -1, 1, 1, 1, 1, 0, "u 'TProofNodes' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofBenchRunDataRead(void) {
   /* TProofBenchRunDataRead */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead));
   G__memfunc_setup("BuildHistos",1130,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - start i - 'Int_t' 0 - stop "
"i - 'Int_t' 0 - step g - 'Bool_t' 0 - nx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillPerfStatProfiles",2036,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TTree' - 0 - t i - 'Int_t' 0 - nactive", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteParameters",1639,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofBenchRunDataRead",2149,G__G__ProofBench_163_0_5, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead), -1, 0, 11, 1, 1, 0, 
"U 'TProofBenchDataSet' - 0 - pbds U 'TPBReadType' - 0 '0' readtype "
"U 'TDirectory' - 0 '0' dirproofbench U 'TProof' - 0 '0' proof "
"U 'TProofNodes' - 0 '0' nodes n - 'Long64_t' 0 '-1' nevents "
"i - 'Int_t' 0 '2' ntries i - 'Int_t' 0 '1' start "
"i - 'Int_t' 0 '-1' stop i - 'Int_t' 0 '1' step "
"i - 'Int_t' 0 '0' debug", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"n - 'Long64_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - dset i - 'Int_t' 0 - start "
"i - 'Int_t' 0 - stop i - 'Int_t' 0 - step "
"i - 'Int_t' 0 - ntries i - 'Int_t' 0 - debug "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDataSet",966,G__G__ProofBench_163_0_8, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TFileCollection), -1, 0, 3, 1, 1, 0, 
"C - - 10 - dset i - 'Int_t' 0 - nact "
"g - 'Bool_t' 0 - nx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPerfProfiles",1631,G__G__ProofBench_163_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetReadType",1098,G__G__ProofBench_163_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TPBReadType' - 0 - readtype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEvents",1007,G__G__ProofBench_163_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - nevents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNTries",897,G__G__ProofBench_163_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ntries", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStart",826,G__G__ProofBench_163_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStop",722,G__G__ProofBench_163_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - stop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStep",712,G__G__ProofBench_163_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDebug",787,G__G__ProofBench_163_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - debug", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirProofBench",1585,G__G__ProofBench_163_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFilesPerWrk",1402,G__G__ProofBench_163_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - fpw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReleaseCache",1473,G__G__ProofBench_163_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadType",1086,G__G__ProofBench_163_0_21, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBReadType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEvents",995,G__G__ProofBench_163_0_22, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTries",885,G__G__ProofBench_163_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStart",814,G__G__ProofBench_163_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStop",710,G__G__ProofBench_163_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStep",700,G__G__ProofBench_163_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDebug",775,G__G__ProofBench_163_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirProofBench",1573,G__G__ProofBench_163_0_28, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCPerfProfiles",1588,G__G__ProofBench_163_0_29, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNameStem",1082,G__G__ProofBench_163_0_31, 117, G__get_linked_tagnum(&G__G__ProofBenchLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__ProofBench_163_0_32, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofBenchRunDataRead::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_163_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRunDataRead::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_163_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofBenchRunDataRead::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_163_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofBenchRunDataRead::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_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__ProofBench_163_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRunDataRead::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_163_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchRunDataRead::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_163_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRunDataRead::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_163_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchRunDataRead::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofBenchRunDataRead", 2149, G__G__ProofBench_163_0_44, (int) ('i'), 
G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead), -1, 0, 1, 1, 1, 0, "u 'TProofBenchRunDataRead' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofBenchRunDataRead", 2275, G__G__ProofBench_163_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofBench_163_0_46, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunDataRead), -1, 1, 1, 1, 1, 0, "u 'TProofBenchRunDataRead' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofBenchRunCPU(void) {
   /* TProofBenchRunCPU */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU));
   G__memfunc_setup("BuildHistos",1130,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - start i - 'Int_t' 0 - stop "
"i - 'Int_t' 0 - step g - 'Bool_t' 0 - nx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillPerfStatPerfPlots",2127,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TTree' - 0 - t i - 'Int_t' 0 - nactive", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteParameters",1639,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofBenchRunCPU",1623,G__G__ProofBench_165_0_5, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU), -1, 0, 12, 1, 1, 0, 
"U 'TPBHistType' - 0 '0' histtype i - 'Int_t' 0 '16' nhists "
"U 'TDirectory' - 0 '0' dirproofbench U 'TProof' - 0 '0' proof "
"U 'TProofNodes' - 0 '0' nodes n - 'Long64_t' 0 '1000000' nevents "
"i - 'Int_t' 0 '2' ntries i - 'Int_t' 0 '1' start "
"i - 'Int_t' 0 '-1' stop i - 'Int_t' 0 '1' step "
"i - 'Int_t' 0 '0' draw i - 'Int_t' 0 '0' debug", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"n - 'Long64_t' 0 - nevents i - 'Int_t' 0 - start "
"i - 'Int_t' 0 - stop i - 'Int_t' 0 - step "
"i - 'Int_t' 0 - ntries i - 'Int_t' 0 - debug "
"i - 'Int_t' 0 - draw", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPerfPlots",1325,G__G__ProofBench_165_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHistType",1126,G__G__ProofBench_165_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TPBHistType' - 0 - histtype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNHists",901,G__G__ProofBench_165_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nhists", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEvents",1007,G__G__ProofBench_165_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - nevents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNTries",897,G__G__ProofBench_165_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ntries", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStart",826,G__G__ProofBench_165_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStop",722,G__G__ProofBench_165_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - stop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStep",712,G__G__ProofBench_165_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDraw",698,G__G__ProofBench_165_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - draw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDebug",787,G__G__ProofBench_165_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - debug", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirProofBench",1585,G__G__ProofBench_165_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistType",1114,G__G__ProofBench_165_0_20, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TPBHistType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNHists",889,G__G__ProofBench_165_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEvents",995,G__G__ProofBench_165_0_22, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTries",885,G__G__ProofBench_165_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStart",814,G__G__ProofBench_165_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStop",710,G__G__ProofBench_165_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStep",700,G__G__ProofBench_165_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDraw",686,G__G__ProofBench_165_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDebug",775,G__G__ProofBench_165_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirProofBench",1573,G__G__ProofBench_165_0_29, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListPerfPlots",1627,G__G__ProofBench_165_0_30, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvas",892,G__G__ProofBench_165_0_31, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNameStem",1082,G__G__ProofBench_165_0_33, 117, G__get_linked_tagnum(&G__G__ProofBenchLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__ProofBench_165_0_34, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofBenchRunCPU::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_165_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRunCPU::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_165_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofBenchRunCPU::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_165_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofBenchRunCPU::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_165_0_41, 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__ProofBench_165_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRunCPU::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_165_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchRunCPU::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_165_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBenchRunCPU::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_165_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBenchRunCPU::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofBenchRunCPU", 1623, G__G__ProofBench_165_0_46, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU), -1, 0, 1, 1, 1, 0, "u 'TProofBenchRunCPU' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofBenchRunCPU", 1749, G__G__ProofBench_165_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofBench_165_0_48, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBenchRunCPU), -1, 1, 1, 1, 1, 0, "u 'TProofBenchRunCPU' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProofBench(void) {
   /* TProofBench */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench));
   G__memfunc_setup("GetGraph",786,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TGraphErrors), -1, 0, 9, 3, 2, 0, 
"U 'TDirectory' - 0 - d C - - 10 - pfn "
"i - 'Int_t' 1 - nb d - 'Double_t' 1 - xmi "
"d - 'Double_t' 1 - xmx d - 'Double_t' 1 - ymi "
"d - 'Double_t' 1 - ymx i - 'Int_t' 1 - kmx "
"U 'TProfile' - 1 - pf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertFittingFun",1648,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"d - 'Double_t' 0 - mi d - 'Double_t' 0 - mx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProofBench",1082,G__G__ProofBench_168_0_3, 105, G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench), -1, 0, 3, 1, 1, 0, 
"C - - 10 - url C - - 10 '\"<default>\"' outfile "
"C - - 10 '0' proofopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunCPU",541,G__G__ProofBench_168_0_4, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"n - 'Long64_t' 0 '-1' nevents i - 'Int_t' 0 '-1' start "
"i - 'Int_t' 0 '-1' stop i - 'Int_t' 0 '-1' step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunCPUx",661,G__G__ProofBench_168_0_5, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"n - 'Long64_t' 0 '-1' nevents i - 'Int_t' 0 '-1' start "
"i - 'Int_t' 0 '-1' stop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunDataSet",987,G__G__ProofBench_168_0_6, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 '\"BenchDataSet\"' dset i - 'Int_t' 0 '1' start "
"i - 'Int_t' 0 '-1' stop i - 'Int_t' 0 '1' step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunDataSetx",1107,G__G__ProofBench_168_0_7, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '\"BenchDataSet\"' dset i - 'Int_t' 0 '1' start "
"i - 'Int_t' 0 '-1' stop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyDataSet",1089,G__G__ProofBench_168_0_8, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - dset C - - 10 - dsetdst "
"C - - 10 - destdir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeDataSet",1060,G__G__ProofBench_168_0_9, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 '0' dset n - 'Long64_t' 0 '-1' nevt "
"C - - 10 '\"event\"' fnroot g - 'Bool_t' 0 'kFALSE' regenerate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseCache",1173,G__G__ProofBench_168_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveDataSet",1300,G__G__ProofBench_168_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseOutFile",1198,G__G__ProofBench_168_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenOutFile",1098,G__G__ProofBench_168_0_13, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' wrt g - 'Bool_t' 0 'kTRUE' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutFile",996,G__G__ProofBench_168_0_14, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - outfile g - 'Bool_t' 0 'kTRUE' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutFileName",1369,G__G__ProofBench_168_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNFilesWrk",1185,G__G__ProofBench_168_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' nf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNTries",897,G__G__ProofBench_168_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistType",1126,G__G__ProofBench_168_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TPBHistType' - 0 - histtype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNHist",786,G__G__ProofBench_168_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadType",1098,G__G__ProofBench_168_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TPBReadType' - 0 - readtype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReleaseCache",1473,G__G__ProofBench_168_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCPUSel",824,G__G__ProofBench_168_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCPUPar",823,G__G__ProofBench_168_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataSel",970,G__G__ProofBench_168_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataPar",969,G__G__ProofBench_168_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataGenSel",1252,G__G__ProofBench_168_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataGenPar",1251,G__G__ProofBench_168_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProofDS",969,G__G__ProofBench_168_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDebug",787,G__G__ProofBench_168_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' debug", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDebug",775,G__G__ProofBench_168_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCPU",630,G__G__ProofBench_168_0_31, 121, -1, -1, 0, 6, 3, 1, 0, 
"C - - 10 - outfile C - - 10 '\"std:\"' opt "
"g - 'Bool_t' 0 'kFALSE' verbose i - 'Int_t' 0 '0' dofit "
"i - 'Int_t' 0 '-1' n0 i - 'Int_t' 0 '-1' n1", (char*)NULL, (void*) G__func2void( (void (*)(const char*, const char*, Bool_t, Int_t, Int_t, Int_t))(&TProofBench::DrawCPU) ), 0);
   G__memfunc_setup("DrawDataSet",1076,G__G__ProofBench_168_0_32, 121, -1, -1, 0, 7, 3, 1, 0, 
"C - - 10 - outfile C - - 10 '\"std:\"' opt "
"C - - 10 '\"mbs\"' type g - 'Bool_t' 0 'kFALSE' verbose "
"i - 'Int_t' 0 '0' dofit i - 'Int_t' 0 '-1' n0 "
"i - 'Int_t' 0 '-1' n1", (char*)NULL, (void*) G__func2void( (void (*)(const char*, const char*, const char*, Bool_t, Int_t, Int_t, Int_t))(&TProofBench::DrawDataSet) ), 0);
   G__memfunc_setup("GetPerfSpecs",1195,G__G__ProofBench_168_0_33, 121, -1, -1, 0, 2, 3, 1, 0, 
"C - - 10 '\".\"' path i - 'Int_t' 0 '1' degfit", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Int_t))(&TProofBench::GetPerfSpecs) ), 0);
   G__memfunc_setup("DrawEfficiency",1411,G__G__ProofBench_168_0_34, 121, -1, -1, 0, 3, 3, 1, 0, 
"C - - 10 - outfile C - - 10 '\"\"' opt "
"g - 'Bool_t' 0 'kFALSE' verbose", (char*)NULL, (void*) G__func2void( (void (*)(const char*, const char*, Bool_t))(&TProofBench::DrawEfficiency) ), 0);
   G__memfunc_setup("GetGraphs",901,G__G__ProofBench_168_0_35, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TList), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TList* (*)())(&TProofBench::GetGraphs) ), 0);
   G__memfunc_setup("Class",502,G__G__ProofBench_168_0_36, 85, G__get_linked_tagnum(&G__G__ProofBenchLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofBench::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__ProofBench_168_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBench::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__ProofBench_168_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofBench::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__ProofBench_168_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofBench::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofBenchLN_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__ProofBench_168_0_43, 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__ProofBench_168_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBench::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__ProofBench_168_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBench::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__ProofBench_168_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofBench::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__ProofBench_168_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofBench::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TProofBench", 1082, G__G__ProofBench_168_0_48, (int) ('i'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench), -1, 0, 1, 1, 1, 0, "u 'TProofBench' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TProofBench", 1208, G__G__ProofBench_168_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__ProofBench_168_0_50, (int) ('u'), G__get_linked_tagnum(&G__G__ProofBenchLN_TProofBench), -1, 1, 1, 1, 1, 0, "u 'TProofBench' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__ProofBench() {
}

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

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

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {

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

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

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__ProofBench() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__ProofBenchLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TSortedList = { "TSortedList" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TH2F = { "TH2F" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofPerfAnalysis = { "TProofPerfAnalysis" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TPBReadType = { "TPBReadType" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TPBReadTypecLcLEReadType = { "TPBReadType::EReadType" , 101 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TPBHistType = { "TPBHistType" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TPBHistTypecLcLEHistType = { "TPBHistType::EHistType" , 101 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TPBHandleDSType = { "TPBHandleDSType" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType = { "TPBHandleDSType::EHandleDSType" , 101 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProof = { "TProof" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofBenchRun = { "TProofBenchRun" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProfile = { "TProfile" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TLegend = { "TLegend" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TFileCollection = { "TFileCollection" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofBenchDataSet = { "TProofBenchDataSet" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofNodes = { "TProofNodes" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofBenchRunDataRead = { "TProofBenchRunDataRead" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofBenchRunCPU = { "TProofBenchRunCPU" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TGraphErrors = { "TGraphErrors" , 99 , -1 };
G__linked_taginfo G__G__ProofBenchLN_TProofBench = { "TProofBench" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__ProofBench() {
  G__G__ProofBenchLN_TClass.tagnum = -1 ;
  G__G__ProofBenchLN_TBuffer.tagnum = -1 ;
  G__G__ProofBenchLN_TDirectory.tagnum = -1 ;
  G__G__ProofBenchLN_TMemberInspector.tagnum = -1 ;
  G__G__ProofBenchLN_TObject.tagnum = -1 ;
  G__G__ProofBenchLN_TNamed.tagnum = -1 ;
  G__G__ProofBenchLN_TString.tagnum = -1 ;
  G__G__ProofBenchLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__ProofBenchLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ProofBenchLN_TList.tagnum = -1 ;
  G__G__ProofBenchLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__ProofBenchLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ProofBenchLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__ProofBenchLN_TSortedList.tagnum = -1 ;
  G__G__ProofBenchLN_TFile.tagnum = -1 ;
  G__G__ProofBenchLN_TH1F.tagnum = -1 ;
  G__G__ProofBenchLN_TH2F.tagnum = -1 ;
  G__G__ProofBenchLN_TTree.tagnum = -1 ;
  G__G__ProofBenchLN_TProofPerfAnalysis.tagnum = -1 ;
  G__G__ProofBenchLN_TPBReadType.tagnum = -1 ;
  G__G__ProofBenchLN_TPBReadTypecLcLEReadType.tagnum = -1 ;
  G__G__ProofBenchLN_TPBHistType.tagnum = -1 ;
  G__G__ProofBenchLN_TPBHistTypecLcLEHistType.tagnum = -1 ;
  G__G__ProofBenchLN_TPBHandleDSType.tagnum = -1 ;
  G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType.tagnum = -1 ;
  G__G__ProofBenchLN_TProof.tagnum = -1 ;
  G__G__ProofBenchLN_TProofBenchRun.tagnum = -1 ;
  G__G__ProofBenchLN_TCanvas.tagnum = -1 ;
  G__G__ProofBenchLN_TH2.tagnum = -1 ;
  G__G__ProofBenchLN_TProfile.tagnum = -1 ;
  G__G__ProofBenchLN_TLegend.tagnum = -1 ;
  G__G__ProofBenchLN_TFileCollection.tagnum = -1 ;
  G__G__ProofBenchLN_TProofBenchDataSet.tagnum = -1 ;
  G__G__ProofBenchLN_TProofNodes.tagnum = -1 ;
  G__G__ProofBenchLN_TProofBenchRunDataRead.tagnum = -1 ;
  G__G__ProofBenchLN_TMap.tagnum = -1 ;
  G__G__ProofBenchLN_TProofBenchRunCPU.tagnum = -1 ;
  G__G__ProofBenchLN_TF1.tagnum = -1 ;
  G__G__ProofBenchLN_TGraphErrors.tagnum = -1 ;
  G__G__ProofBenchLN_TProofBench.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__ProofBench() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TString);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TList);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TSortedList);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TFile);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TH1F);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TH2F);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofPerfAnalysis),sizeof(TProofPerfAnalysis),-1,324608,"Set of tools to analyse the performance tree",G__setup_memvarTProofPerfAnalysis,G__setup_memfuncTProofPerfAnalysis);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TPBReadType),sizeof(TPBReadType),-1,292096,"Streamable PBReadType",G__setup_memvarTPBReadType,G__setup_memfuncTPBReadType);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TPBReadTypecLcLEReadType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TPBHistType),sizeof(TPBHistType),-1,292096,"Streamable PBHistType",G__setup_memvarTPBHistType,G__setup_memfuncTPBHistType);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TPBHistTypecLcLEHistType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TPBHandleDSType),sizeof(TPBHandleDSType),-1,292096,"Streamable PBHandleDSType",G__setup_memvarTPBHandleDSType,G__setup_memfuncTPBHandleDSType);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TPBHandleDSTypecLcLEHandleDSType);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProof);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofBenchRun),sizeof(TProofBenchRun),-1,292099,"Abstract base class for PROOF benchmark run",G__setup_memvarTProofBenchRun,G__setup_memfuncTProofBenchRun);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TCanvas);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TH2);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProfile);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TLegend);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TFileCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofBenchDataSet),sizeof(TProofBenchDataSet),-1,292096,"Handle operations on datasets",G__setup_memvarTProofBenchDataSet,G__setup_memfuncTProofBenchDataSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofNodes),sizeof(TProofNodes),-1,324608,"Node and worker information",G__setup_memvarTProofNodes,G__setup_memfuncTProofNodes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofBenchRunDataRead),sizeof(TProofBenchRunDataRead),-1,324608,"IO-intensive PROOF benchmark",G__setup_memvarTProofBenchRunDataRead,G__setup_memfuncTProofBenchRunDataRead);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofBenchRunCPU),sizeof(TProofBenchRunCPU),-1,292096,"CPU-intensive PROOF benchmark",G__setup_memvarTProofBenchRunCPU,G__setup_memfuncTProofBenchRunCPU);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TF1);
   G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TGraphErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofBenchLN_TProofBench),sizeof(TProofBench),-1,324608,"Steering class for PROOF benchmarks",G__setup_memvarTProofBench,G__setup_memfuncTProofBench);
}
extern "C" void G__cpp_setupG__ProofBench(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__ProofBench()");
  G__set_cpp_environmentG__ProofBench();
  G__cpp_setup_tagtableG__ProofBench();

  G__cpp_setup_inheritanceG__ProofBench();

  G__cpp_setup_typetableG__ProofBench();

  G__cpp_setup_memvarG__ProofBench();

  G__cpp_setup_memfuncG__ProofBench();
  G__cpp_setup_globalG__ProofBench();
  G__cpp_setup_funcG__ProofBench();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__ProofBench();
  return;
}
class G__cpp_setup_initG__ProofBench {
  public:
    G__cpp_setup_initG__ProofBench() { G__add_setup_func("G__ProofBench",(G__incsetup)(&G__cpp_setupG__ProofBench)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__ProofBench() { G__remove_setup_func("G__ProofBench"); }
};
G__cpp_setup_initG__ProofBench G__cpp_setup_initializerG__ProofBench;